Repository: juhgiyo/EpPathFinding.cs
Branch: master
Commit: e0d3d4bf7353
Files: 38
Total size: 182.9 KB
Directory structure:
gitextract_a16lqtoo/
├── .gitignore
├── EpPathFinding.cs/
│ ├── EpPathFinding.cs/
│ │ ├── EpPathFinding.cs.csproj
│ │ ├── PathFinder/
│ │ │ ├── AStarFinder.cs
│ │ │ ├── DiagonalMovement.cs
│ │ │ ├── Grid/
│ │ │ │ ├── BaseGrid.cs
│ │ │ │ ├── DynamicGrid.cs
│ │ │ │ ├── DynamicGridWPool.cs
│ │ │ │ ├── PartialGridWPool.cs
│ │ │ │ └── StaticGrid.cs
│ │ │ ├── GridPos.cs
│ │ │ ├── GridRect.cs
│ │ │ ├── Heuristic.cs
│ │ │ ├── JumpPointFinder.cs
│ │ │ ├── NodePool.cs
│ │ │ ├── ParamBase.cs
│ │ │ └── Util.cs
│ │ ├── Properties/
│ │ │ └── AssemblyInfo.cs
│ │ └── packages.config
│ ├── EpPathFinding.cs.nupkg
│ └── EpPathFinding.cs.sln
├── EpPathFindingDemo/
│ ├── EpPathFindingDemo.csproj
│ ├── EpPathFindingDemo.sln
│ ├── General/
│ │ └── SingletonHolder.cs
│ ├── GridBox.cs
│ ├── GridLine.cs
│ ├── LICENSE
│ ├── Program.cs
│ ├── Properties/
│ │ ├── AssemblyInfo.cs
│ │ ├── Resources.Designer.cs
│ │ ├── Resources.resx
│ │ ├── Settings.Designer.cs
│ │ └── Settings.settings
│ ├── ResultBox.cs
│ ├── SearchGridForm.Designer.cs
│ ├── SearchGridForm.cs
│ └── SearchGridForm.resx
├── README.md
└── _config.yml
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
*.pdb
Debug/
Release/
*.suo
packages/
================================================
FILE: EpPathFinding.cs/EpPathFinding.cs/EpPathFinding.cs.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>8.0.30703</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{4BC2B4B0-2A38-4274-98A2-37CEF5F03B42}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>EpPathFinding.cs</RootNamespace>
<AssemblyName>EpPathFinding.cs</AssemblyName>
<TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
<Reference Include="C5, Version=2.4.5947.17248, Culture=neutral, PublicKeyToken=282361b99ded7e8e, processorArchitecture=MSIL">
<HintPath>..\packages\C5.2.4.5947.17249\lib\net40\C5.dll</HintPath>
<Private>True</Private>
</Reference>
<Reference Include="System" />
<Reference Include="System.Core" />
<Reference Include="System.Xml.Linq" />
<Reference Include="System.Data.DataSetExtensions" />
<Reference Include="Microsoft.CSharp" />
<Reference Include="System.Data" />
<Reference Include="System.Xml" />
</ItemGroup>
<ItemGroup>
<Compile Include="PathFinder\AStarFinder.cs" />
<Compile Include="PathFinder\DiagonalMovement.cs" />
<Compile Include="PathFinder\GridPos.cs" />
<Compile Include="PathFinder\GridRect.cs" />
<Compile Include="PathFinder\Grid\BaseGrid.cs" />
<Compile Include="PathFinder\Grid\DynamicGrid.cs" />
<Compile Include="PathFinder\Grid\DynamicGridWPool.cs" />
<Compile Include="PathFinder\Grid\PartialGridWPool.cs" />
<Compile Include="PathFinder\Grid\StaticGrid.cs" />
<Compile Include="PathFinder\Heuristic.cs" />
<Compile Include="PathFinder\JumpPointFinder.cs" />
<Compile Include="PathFinder\NodePool.cs" />
<Compile Include="PathFinder\ParamBase.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="PathFinder\Util.cs" />
</ItemGroup>
<ItemGroup>
<None Include="packages.config" />
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
</Project>
================================================
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/AStarFinder.cs
================================================
#if (UNITY_EDITOR || UNITY_EDITOR_WIN || UNITY_EDITOR_OSX || UNITY_STANDALONE_OSX || UNITY_STANDALONE_WIN || UNITY_STANDALONE_LINUX || UNITY_STANDALONE || UNITY_WII || UNITY_IOS || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS4 || UNITY_SAMSUNGTV || UNITY_XBOXONE || UNITY_TIZEN || UNITY_TVOS || UNITY_WP_8_1 || UNITY_WSA || UNITY_WSA_8_1 || UNITY_WSA_10_0 || UNITY_WINRT || UNITY_WINRT_8_1 || UNITY_WINRT_10_0 || UNITY_WEBGL || UNITY_ADS || UNITY_ANALYTICS || UNITY_ASSERTIONS)
#define UNITY
#else
using System.Threading.Tasks;
#endif
using C5;
using System;
using System.Collections;
using System.Collections.Generic;
namespace EpPathFinding.cs
{
public class AStarParam : ParamBase
{
public delegate float HeuristicDelegate(int iDx, int iDy);
public float Weight;
public AStarParam(BaseGrid iGrid, GridPos iStartPos, GridPos iEndPos, float iweight, DiagonalMovement iDiagonalMovement = DiagonalMovement.Always, HeuristicMode iMode = HeuristicMode.EUCLIDEAN)
: base(iGrid,iStartPos,iEndPos, iDiagonalMovement,iMode)
{
Weight = iweight;
}
public AStarParam(BaseGrid iGrid, float iweight, DiagonalMovement iDiagonalMovement = DiagonalMovement.Always, HeuristicMode iMode = HeuristicMode.EUCLIDEAN)
: base(iGrid, iDiagonalMovement, iMode)
{
Weight = iweight;
}
internal override void _reset(GridPos iStartPos, GridPos iEndPos, BaseGrid iSearchGrid = null)
{
}
}
public static class AStarFinder
{
/*
private class NodeComparer : IComparer<Node>
{
public int Compare(Node x, Node y)
{
var result = (x.heuristicStartToEndLen - y.heuristicStartToEndLen);
if (result < 0) return -1;
else
if (result > 0) return 1;
else
{
return 0;
}
}
}
*/
public static List<GridPos> FindPath(AStarParam iParam)
{
object lo = new object();
//var openList = new IntervalHeap<Node>(new NodeComparer());
var openList = new IntervalHeap<Node>();
var startNode = iParam.StartNode;
var endNode = iParam.EndNode;
var heuristic = iParam.HeuristicFunc;
var grid = iParam.SearchGrid;
var diagonalMovement = iParam.DiagonalMovement;
var weight = iParam.Weight;
startNode.startToCurNodeLen = 0;
startNode.heuristicStartToEndLen = 0;
openList.Add(startNode);
startNode.isOpened = true;
while (openList.Count != 0)
{
var node = openList.DeleteMin();
node.isClosed = true;
if (node == endNode)
{
return Node.Backtrace(endNode);
}
var neighbors = grid.GetNeighbors(node, diagonalMovement);
#if (UNITY)
foreach(var neighbor in neighbors)
#else
Parallel.ForEach(neighbors, neighbor =>
#endif
{
#if (UNITY)
if (neighbor.isClosed) continue;
#else
if (neighbor.isClosed) return;
#endif
var x = neighbor.x;
var y = neighbor.y;
float ng = node.startToCurNodeLen + (float)((x - node.x == 0 || y - node.y == 0) ? 1 : Math.Sqrt(2));
if (!neighbor.isOpened || ng < neighbor.startToCurNodeLen)
{
neighbor.startToCurNodeLen = ng;
if (neighbor.heuristicCurNodeToEndLen == null) neighbor.heuristicCurNodeToEndLen = weight * heuristic(Math.Abs(x - endNode.x), Math.Abs(y - endNode.y));
neighbor.heuristicStartToEndLen = neighbor.startToCurNodeLen + neighbor.heuristicCurNodeToEndLen.Value;
neighbor.parent = node;
if (!neighbor.isOpened)
{
lock (lo)
{
openList.Add(neighbor);
}
neighbor.isOpened = true;
}
else
{
}
}
}
#if (!UNITY)
);
#endif
}
return new List<GridPos>();
}
}
}
================================================
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/DiagonalMovement.cs
================================================
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace EpPathFinding.cs
{
public enum DiagonalMovement
{
Always,
Never,
IfAtLeastOneWalkable,
OnlyWhenNoObstacles
}
}
================================================
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/Grid/BaseGrid.cs
================================================
/*!
@file BaseGrid.cs
@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>
<http://github.com/juhgiyo/eppathfinding.cs>
@date July 16, 2013
@brief BaseGrid Interface
@version 2.0
@section LICENSE
The MIT License (MIT)
Copyright (c) 2013 Woong Gyu La <juhgiyo@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@section DESCRIPTION
An Interface for the BaseGrid Class.
*/
using System;
using System.Collections.Generic;
using System.Collections;
namespace EpPathFinding.cs
{
public class Node : IComparable<Node>
{
public int x;
public int y;
public bool walkable;
public float heuristicStartToEndLen; // which passes current node
public float startToCurNodeLen;
public float? heuristicCurNodeToEndLen;
public bool isOpened;
public bool isClosed;
public Object parent;
public Node(int iX, int iY, bool? iWalkable = null)
{
this.x = iX;
this.y = iY;
this.walkable = (iWalkable.HasValue ? iWalkable.Value : false);
this.heuristicStartToEndLen = 0;
this.startToCurNodeLen = 0;
// this must be initialized as null to verify that its value never initialized
// 0 is not good candidate!!
this.heuristicCurNodeToEndLen = null;
this.isOpened = false;
this.isClosed = false;
this.parent = null;
}
public Node(Node b)
{
this.x = b.x;
this.y = b.y;
this.walkable = b.walkable;
this.heuristicStartToEndLen = b.heuristicStartToEndLen;
this.startToCurNodeLen = b.startToCurNodeLen;
this.heuristicCurNodeToEndLen = b.heuristicCurNodeToEndLen;
this.isOpened = b.isOpened;
this.isClosed = b.isClosed;
this.parent = b.parent;
}
public void Reset(bool? iWalkable = null)
{
if (iWalkable.HasValue)
walkable = iWalkable.Value;
this.heuristicStartToEndLen = 0;
this.startToCurNodeLen = 0;
// this must be initialized as null to verify that its value never initialized
// 0 is not good candidate!!
this.heuristicCurNodeToEndLen = null ;
this.isOpened = false;
this.isClosed = false;
this.parent = null;
}
public int CompareTo(Node iObj)
{
float result = this.heuristicStartToEndLen - iObj.heuristicStartToEndLen;
if (result > 0.0f)
return 1;
else if (result == 0.0f)
return 0;
return -1;
}
public static List<GridPos> Backtrace(Node iNode)
{
List<GridPos> path = new List<GridPos>();
path.Add(new GridPos(iNode.x, iNode.y));
while (iNode.parent != null)
{
iNode = (Node)iNode.parent;
path.Add(new GridPos(iNode.x, iNode.y));
}
path.Reverse();
return path;
}
public override int GetHashCode()
{
return x ^ y;
}
public override bool Equals(System.Object obj)
{
// If parameter is null return false.
if (obj == null)
{
return false;
}
// If parameter cannot be cast to Point return false.
Node p = obj as Node;
if ((System.Object)p == null)
{
return false;
}
// Return true if the fields match:
return (x == p.x) && (y == p.y);
}
public bool Equals(Node p)
{
// If parameter is null return false:
if ((object)p == null)
{
return false;
}
// Return true if the fields match:
return (x == p.x) && (y == p.y);
}
public static bool operator ==(Node a, Node b)
{
// If both are null, or both are same instance, return true.
if (System.Object.ReferenceEquals(a, b))
{
return true;
}
// If one is null, but not both, return false.
if (((object)a == null) || ((object)b == null))
{
return false;
}
// Return true if the fields match:
return a.x == b.x && a.y == b.y;
}
public static bool operator !=(Node a, Node b)
{
return !(a == b);
}
}
public abstract class BaseGrid
{
public BaseGrid()
{
m_gridRect = new GridRect();
}
public BaseGrid(BaseGrid b)
{
m_gridRect = new GridRect(b.m_gridRect);
width = b.width;
height = b.height;
}
protected GridRect m_gridRect;
public GridRect gridRect
{
get { return m_gridRect; }
}
public abstract int width { get; protected set; }
public abstract int height { get; protected set; }
public abstract Node GetNodeAt(int iX, int iY);
public abstract bool IsWalkableAt(int iX, int iY);
public abstract bool SetWalkableAt(int iX, int iY, bool iWalkable);
public abstract Node GetNodeAt(GridPos iPos);
public abstract bool IsWalkableAt(GridPos iPos);
public abstract bool SetWalkableAt(GridPos iPos, bool iWalkable);
public List<Node> GetNeighbors(Node iNode, DiagonalMovement diagonalMovement)
{
int tX = iNode.x;
int tY = iNode.y;
List<Node> neighbors = new List<Node>();
bool tS0 = false, tD0 = false,
tS1 = false, tD1 = false,
tS2 = false, tD2 = false,
tS3 = false, tD3 = false;
GridPos pos = new GridPos();
if (this.IsWalkableAt(pos.Set(tX, tY - 1)))
{
neighbors.Add(GetNodeAt(pos));
tS0 = true;
}
if (this.IsWalkableAt(pos.Set(tX + 1, tY)))
{
neighbors.Add(GetNodeAt(pos));
tS1 = true;
}
if (this.IsWalkableAt(pos.Set(tX, tY + 1)))
{
neighbors.Add(GetNodeAt(pos));
tS2 = true;
}
if (this.IsWalkableAt(pos.Set(tX - 1, tY)))
{
neighbors.Add(GetNodeAt(pos));
tS3 = true;
}
switch (diagonalMovement)
{
case DiagonalMovement.Always:
tD0 = true;
tD1 = true;
tD2 = true;
tD3 = true;
break;
case DiagonalMovement.Never:
break;
case DiagonalMovement.IfAtLeastOneWalkable:
tD0 = tS3 || tS0;
tD1 = tS0 || tS1;
tD2 = tS1 || tS2;
tD3 = tS2 || tS3;
break;
case DiagonalMovement.OnlyWhenNoObstacles:
tD0 = tS3 && tS0;
tD1 = tS0 && tS1;
tD2 = tS1 && tS2;
tD3 = tS2 && tS3;
break;
default:
break;
}
if (tD0 && this.IsWalkableAt(pos.Set(tX - 1, tY - 1)))
{
neighbors.Add(GetNodeAt(pos));
}
if (tD1 && this.IsWalkableAt(pos.Set(tX + 1, tY - 1)))
{
neighbors.Add(GetNodeAt(pos));
}
if (tD2 && this.IsWalkableAt(pos.Set(tX + 1, tY + 1)))
{
neighbors.Add(GetNodeAt(pos));
}
if (tD3 && this.IsWalkableAt(pos.Set(tX - 1, tY + 1)))
{
neighbors.Add(GetNodeAt(pos));
}
return neighbors;
}
public abstract void Reset();
public abstract BaseGrid Clone();
}
}
================================================
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/Grid/DynamicGrid.cs
================================================
/*!
@file DynamicGrid.cs
@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>
<http://github.com/juhgiyo/eppathfinding.cs>
@date July 16, 2013
@brief DynamicGrid Interface
@version 2.0
@section LICENSE
The MIT License (MIT)
Copyright (c) 2013 Woong Gyu La <juhgiyo@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@section DESCRIPTION
An Interface for the DynamicGrid Class.
*/
using System;
using System.Collections.Generic;
using System.Collections;
namespace EpPathFinding.cs
{
public class DynamicGrid : BaseGrid
{
protected Dictionary<GridPos, Node> m_nodes;
private bool m_notSet;
public override int width
{
get
{
if (m_notSet)
setBoundingBox();
return m_gridRect.maxX - m_gridRect.minX + 1;
}
protected set
{
}
}
public override int height
{
get
{
if (m_notSet)
setBoundingBox();
return m_gridRect.maxY - m_gridRect.minY + 1;
}
protected set
{
}
}
public DynamicGrid(List<GridPos> iWalkableGridList = null)
: base()
{
m_gridRect = new GridRect();
m_gridRect.minX = 0;
m_gridRect.minY = 0;
m_gridRect.maxX = 0;
m_gridRect.maxY = 0;
m_notSet = true;
buildNodes(iWalkableGridList);
}
public DynamicGrid(DynamicGrid b)
: base(b)
{
m_notSet = b.m_notSet;
m_nodes = new Dictionary<GridPos, Node>(b.m_nodes);
}
protected void buildNodes(List<GridPos> iWalkableGridList)
{
m_nodes = new Dictionary<GridPos, Node>();
if (iWalkableGridList == null)
return;
foreach (GridPos gridPos in iWalkableGridList)
{
SetWalkableAt(gridPos.x, gridPos.y, true);
}
}
public override Node GetNodeAt(int iX, int iY)
{
GridPos pos = new GridPos(iX, iY);
return GetNodeAt(pos);
}
public override bool IsWalkableAt(int iX, int iY)
{
GridPos pos = new GridPos(iX, iY);
return IsWalkableAt(pos);
}
private void setBoundingBox()
{
m_notSet = true;
foreach (KeyValuePair<GridPos, Node> pair in m_nodes)
{
if (pair.Key.x < m_gridRect.minX || m_notSet)
m_gridRect.minX = pair.Key.x;
if (pair.Key.x > m_gridRect.maxX || m_notSet)
m_gridRect.maxX = pair.Key.x;
if (pair.Key.y < m_gridRect.minY || m_notSet)
m_gridRect.minY = pair.Key.y;
if (pair.Key.y > m_gridRect.maxY || m_notSet)
m_gridRect.maxY = pair.Key.y;
m_notSet = false;
}
m_notSet = false;
}
public override bool SetWalkableAt(int iX, int iY, bool iWalkable)
{
GridPos pos = new GridPos(iX, iY);
if (iWalkable)
{
if (m_nodes.ContainsKey(pos))
{
// this.m_nodes[pos].walkable = iWalkable;
return true;
}
else
{
if (iX < m_gridRect.minX || m_notSet)
m_gridRect.minX = iX;
if (iX > m_gridRect.maxX || m_notSet)
m_gridRect.maxX = iX;
if (iY < m_gridRect.minY || m_notSet)
m_gridRect.minY = iY;
if (iY > m_gridRect.maxY || m_notSet)
m_gridRect.maxY = iY;
m_nodes.Add(new GridPos(pos.x, pos.y), new Node(pos.x, pos.y, iWalkable));
//m_notSet = false;
}
}
else
{
if (m_nodes.ContainsKey(pos))
{
m_nodes.Remove(pos);
if (iX == m_gridRect.minX || iX == m_gridRect.maxX || iY == m_gridRect.minY || iY == m_gridRect.maxY)
m_notSet = true;
}
}
return true;
}
public override Node GetNodeAt(GridPos iPos)
{
if (m_nodes.ContainsKey(iPos))
{
return m_nodes[iPos];
}
return null;
}
public override bool IsWalkableAt(GridPos iPos)
{
return m_nodes.ContainsKey(iPos);
}
public override bool SetWalkableAt(GridPos iPos, bool iWalkable)
{
return SetWalkableAt(iPos.x, iPos.y, iWalkable);
}
public override void Reset()
{
Reset(null);
}
public void Reset(List<GridPos> iWalkableGridList)
{
foreach (KeyValuePair<GridPos, Node> keyValue in m_nodes)
{
keyValue.Value.Reset();
}
if (iWalkableGridList == null)
return;
foreach (KeyValuePair<GridPos, Node> keyValue in m_nodes)
{
if (iWalkableGridList.Contains(keyValue.Key))
SetWalkableAt(keyValue.Key, true);
else
SetWalkableAt(keyValue.Key, false);
}
}
public override BaseGrid Clone()
{
DynamicGrid tNewGrid = new DynamicGrid();
foreach (KeyValuePair<GridPos, Node> keyValue in m_nodes)
{
tNewGrid.SetWalkableAt(keyValue.Key.x, keyValue.Key.y, true);
}
return tNewGrid;
}
}
}
================================================
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/Grid/DynamicGridWPool.cs
================================================
/*!
@file DynamicGridWPool.cs
@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>
<http://github.com/juhgiyo/eppathfinding.cs>
@date July 16, 2013
@brief DynamicGrid with Pool Interface
@version 2.0
@section LICENSE
The MIT License (MIT)
Copyright (c) 2013 Woong Gyu La <juhgiyo@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@section DESCRIPTION
An Interface for the DynamicGrid with Pool Class.
*/
using System;
using System.Collections.Generic;
using System.Collections;
namespace EpPathFinding.cs
{
public class DynamicGridWPool : BaseGrid
{
private bool m_notSet;
private NodePool m_nodePool;
public override int width
{
get
{
if (m_notSet)
setBoundingBox();
return m_gridRect.maxX - m_gridRect.minX + 1;
}
protected set
{
}
}
public override int height
{
get
{
if (m_notSet)
setBoundingBox();
return m_gridRect.maxY - m_gridRect.minY + 1;
}
protected set
{
}
}
public DynamicGridWPool(NodePool iNodePool)
: base()
{
m_gridRect = new GridRect();
m_gridRect.minX = 0;
m_gridRect.minY = 0;
m_gridRect.maxX = 0;
m_gridRect.maxY = 0;
m_notSet = true;
m_nodePool = iNodePool;
}
public DynamicGridWPool(DynamicGridWPool b)
: base(b)
{
m_notSet = b.m_notSet;
m_nodePool = b.m_nodePool;
}
public override Node GetNodeAt(int iX, int iY)
{
GridPos pos = new GridPos(iX, iY);
return GetNodeAt(pos);
}
public override bool IsWalkableAt(int iX, int iY)
{
GridPos pos = new GridPos(iX, iY);
return IsWalkableAt(pos);
}
private void setBoundingBox()
{
m_notSet = true;
foreach (KeyValuePair<GridPos, Node> pair in m_nodePool.Nodes)
{
if (pair.Key.x < m_gridRect.minX || m_notSet)
m_gridRect.minX = pair.Key.x;
if (pair.Key.x > m_gridRect.maxX || m_notSet)
m_gridRect.maxX = pair.Key.x;
if (pair.Key.y < m_gridRect.minY || m_notSet)
m_gridRect.minY = pair.Key.y;
if (pair.Key.y > m_gridRect.maxY || m_notSet)
m_gridRect.maxY = pair.Key.y;
m_notSet = false;
}
m_notSet = false;
}
public override bool SetWalkableAt(int iX, int iY, bool iWalkable)
{
GridPos pos = new GridPos(iX, iY);
m_nodePool.SetNode(pos, iWalkable);
if (iWalkable)
{
if (iX < m_gridRect.minX || m_notSet)
m_gridRect.minX = iX;
if (iX > m_gridRect.maxX || m_notSet)
m_gridRect.maxX = iX;
if (iY < m_gridRect.minY || m_notSet)
m_gridRect.minY = iY;
if (iY > m_gridRect.maxY || m_notSet)
m_gridRect.maxY = iY;
//m_notSet = false;
}
else
{
if (iX == m_gridRect.minX || iX == m_gridRect.maxX || iY == m_gridRect.minY || iY == m_gridRect.maxY)
m_notSet = true;
}
return true;
}
public override Node GetNodeAt(GridPos iPos)
{
return m_nodePool.GetNode(iPos);
}
public override bool IsWalkableAt(GridPos iPos)
{
return m_nodePool.Nodes.ContainsKey(iPos);
}
public override bool SetWalkableAt(GridPos iPos, bool iWalkable)
{
return SetWalkableAt(iPos.x, iPos.y, iWalkable);
}
public override void Reset()
{
foreach (KeyValuePair<GridPos, Node> keyValue in m_nodePool.Nodes)
{
keyValue.Value.Reset();
}
}
public override BaseGrid Clone()
{
DynamicGridWPool tNewGrid = new DynamicGridWPool(m_nodePool);
return tNewGrid;
}
}
}
================================================
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/Grid/PartialGridWPool.cs
================================================
/*!
@file PartialGridWPool.cs
@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>
<http://github.com/juhgiyo/eppathfinding.cs>
@date July 16, 2013
@brief PartialGrid with Pool Interface
@version 2.0
@section LICENSE
The MIT License (MIT)
Copyright (c) 2013 Woong Gyu La <juhgiyo@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@section DESCRIPTION
An Interface for the PartialGrid with Pool Class.
*/
using System;
using System.Collections.Generic;
using System.Collections;
namespace EpPathFinding.cs
{
public class PartialGridWPool : BaseGrid
{
private NodePool m_nodePool;
public override int width
{
get
{
return m_gridRect.maxX - m_gridRect.minX + 1;
}
protected set
{
}
}
public override int height
{
get
{
return m_gridRect.maxY - m_gridRect.minY + 1;
}
protected set
{
}
}
public PartialGridWPool(NodePool iNodePool, GridRect iGridRect = null)
: base()
{
if (iGridRect == null)
m_gridRect = new GridRect();
else
m_gridRect = iGridRect;
m_nodePool = iNodePool;
}
public PartialGridWPool(PartialGridWPool b)
: base(b)
{
m_nodePool = b.m_nodePool;
}
public void SetGridRect(GridRect iGridRect)
{
m_gridRect = iGridRect;
}
public bool IsInside(int iX, int iY)
{
if (iX < m_gridRect.minX || iX > m_gridRect.maxX || iY < m_gridRect.minY || iY > m_gridRect.maxY)
return false;
return true;
}
public override Node GetNodeAt(int iX, int iY)
{
GridPos pos = new GridPos(iX, iY);
return GetNodeAt(pos);
}
public override bool IsWalkableAt(int iX, int iY)
{
GridPos pos = new GridPos(iX, iY);
return IsWalkableAt(pos);
}
public override bool SetWalkableAt(int iX, int iY, bool iWalkable)
{
if (!IsInside(iX,iY))
return false;
GridPos pos = new GridPos(iX, iY);
m_nodePool.SetNode(pos, iWalkable);
return true;
}
public bool IsInside(GridPos iPos)
{
return IsInside(iPos.x, iPos.y);
}
public override Node GetNodeAt(GridPos iPos)
{
if (!IsInside(iPos))
return null;
return m_nodePool.GetNode(iPos);
}
public override bool IsWalkableAt(GridPos iPos)
{
if (!IsInside(iPos))
return false;
return m_nodePool.Nodes.ContainsKey(iPos);
}
public override bool SetWalkableAt(GridPos iPos, bool iWalkable)
{
return SetWalkableAt(iPos.x, iPos.y, iWalkable);
}
public override void Reset()
{
int rectCount=(m_gridRect.maxX-m_gridRect.minX) * (m_gridRect.maxY-m_gridRect.minY);
if (m_nodePool.Nodes.Count > rectCount)
{
GridPos travPos = new GridPos(0, 0);
for (int xTrav = m_gridRect.minX; xTrav <= m_gridRect.maxX; xTrav++)
{
travPos.x = xTrav;
for (int yTrav = m_gridRect.minY; yTrav <= m_gridRect.maxY; yTrav++)
{
travPos.y = yTrav;
Node curNode=m_nodePool.GetNode(travPos);
if (curNode!=null)
curNode.Reset();
}
}
}
else
{
foreach (KeyValuePair<GridPos, Node> keyValue in m_nodePool.Nodes)
{
keyValue.Value.Reset();
}
}
}
public override BaseGrid Clone()
{
PartialGridWPool tNewGrid = new PartialGridWPool(m_nodePool,m_gridRect);
return tNewGrid;
}
}
}
================================================
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/Grid/StaticGrid.cs
================================================
/*!
@file StaticGrid.cs
@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>
<http://github.com/juhgiyo/eppathfinding.cs>
@date July 16, 2013
@brief StaticGrid Interface
@version 2.0
@section LICENSE
The MIT License (MIT)
Copyright (c) 2013 Woong Gyu La <juhgiyo@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@section DESCRIPTION
An Interface for the StaticGrid Class.
*/
using System;
using System.Collections.Generic;
using System.Collections;
namespace EpPathFinding.cs
{
public class StaticGrid : BaseGrid
{
public override int width { get; protected set; }
public override int height { get; protected set; }
private Node[][] m_nodes;
public StaticGrid(int iWidth, int iHeight, bool[][] iMatrix = null):base()
{
width = iWidth;
height = iHeight;
m_gridRect.minX = 0;
m_gridRect.minY = 0;
m_gridRect.maxX = iWidth-1;
m_gridRect.maxY = iHeight - 1;
this.m_nodes = buildNodes(iWidth, iHeight, iMatrix);
}
public StaticGrid(StaticGrid b)
: base(b)
{
bool[][] tMatrix = new bool[b.width][];
for (int widthTrav = 0; widthTrav < b.width; widthTrav++)
{
tMatrix[widthTrav] = new bool[b.height];
for (int heightTrav = 0; heightTrav < b.height; heightTrav++)
{
if(b.IsWalkableAt(widthTrav,heightTrav))
tMatrix[widthTrav][heightTrav] = true;
else
tMatrix[widthTrav][heightTrav] = false;
}
}
this.m_nodes = buildNodes(b.width, b.height, tMatrix);
}
private Node[][] buildNodes(int iWidth, int iHeight, bool[][] iMatrix)
{
Node[][] tNodes = new Node[iWidth][];
for (int widthTrav = 0; widthTrav < iWidth; widthTrav++)
{
tNodes[widthTrav] = new Node[iHeight];
for (int heightTrav = 0; heightTrav < iHeight; heightTrav++)
{
tNodes[widthTrav][heightTrav] = new Node(widthTrav, heightTrav, null);
}
}
if (iMatrix == null)
{
return tNodes;
}
if (iMatrix.Length != iWidth || iMatrix[0].Length != iHeight)
{
throw new System.Exception("Matrix size does not fit");
}
for (int widthTrav = 0; widthTrav < iWidth; widthTrav++)
{
for (int heightTrav = 0; heightTrav < iHeight; heightTrav++)
{
if (iMatrix[widthTrav][heightTrav])
{
tNodes[widthTrav][heightTrav].walkable = true;
}
else
{
tNodes[widthTrav][heightTrav].walkable = false;
}
}
}
return tNodes;
}
public override Node GetNodeAt(int iX, int iY)
{
return this.m_nodes[iX][iY];
}
public override bool IsWalkableAt(int iX, int iY)
{
return isInside(iX, iY) && this.m_nodes[iX][iY].walkable;
}
protected bool isInside(int iX, int iY)
{
return (iX >= 0 && iX < width) && (iY >= 0 && iY < height);
}
public override bool SetWalkableAt(int iX, int iY, bool iWalkable)
{
this.m_nodes[iX][iY].walkable = iWalkable;
return true;
}
protected bool isInside(GridPos iPos)
{
return isInside(iPos.x, iPos.y);
}
public override Node GetNodeAt(GridPos iPos)
{
return GetNodeAt(iPos.x, iPos.y);
}
public override bool IsWalkableAt(GridPos iPos)
{
return IsWalkableAt(iPos.x, iPos.y);
}
public override bool SetWalkableAt(GridPos iPos, bool iWalkable)
{
return SetWalkableAt(iPos.x, iPos.y, iWalkable);
}
public override void Reset()
{
Reset(null);
}
public void Reset(bool[][] iMatrix)
{
for (int widthTrav = 0; widthTrav < width; widthTrav++)
{
for (int heightTrav = 0; heightTrav < height; heightTrav++)
{
m_nodes[widthTrav][heightTrav].Reset();
}
}
if (iMatrix == null)
{
return;
}
if (iMatrix.Length != width || iMatrix[0].Length != height)
{
throw new System.Exception("Matrix size does not fit");
}
for (int widthTrav = 0; widthTrav < width; widthTrav++)
{
for (int heightTrav = 0; heightTrav < height; heightTrav++)
{
if (iMatrix[widthTrav][heightTrav])
{
m_nodes[widthTrav][heightTrav].walkable = true;
}
else
{
m_nodes[widthTrav][heightTrav].walkable = false;
}
}
}
}
public override BaseGrid Clone()
{
int tWidth = width;
int tHeight = height;
Node[][] tNodes = this.m_nodes;
StaticGrid tNewGrid = new StaticGrid(tWidth, tHeight, null);
Node[][] tNewNodes = new Node[tWidth][];
for (int widthTrav = 0; widthTrav < tWidth; widthTrav++)
{
tNewNodes[widthTrav] = new Node[tHeight];
for (int heightTrav = 0; heightTrav < tHeight; heightTrav++)
{
tNewNodes[widthTrav][heightTrav] = new Node(widthTrav, heightTrav, tNodes[widthTrav][heightTrav].walkable);
}
}
tNewGrid.m_nodes = tNewNodes;
return tNewGrid;
}
}
}
================================================
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/GridPos.cs
================================================
/*!
@file GridPos.cs
@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>
<http://github.com/juhgiyo/eppathfinding.cs>
@date July 16, 2013
@brief Grid Position Interface
@version 2.0
@section LICENSE
The MIT License (MIT)
Copyright (c) 2013 Woong Gyu La <juhgiyo@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@section DESCRIPTION
An Interface for the Grid Position Struct.
*/
using System;
using System.Collections.Generic;
using System.Collections;
namespace EpPathFinding.cs
{
public class GridPos : IEquatable<GridPos>
{
public int x;
public int y;
public GridPos()
{
x = 0;
y = 0;
}
public GridPos(int iX, int iY)
{
this.x = iX;
this.y = iY;
}
public GridPos(GridPos b)
{
x = b.x;
y = b.y;
}
public override int GetHashCode()
{
return x ^ y;
}
public override bool Equals(System.Object obj)
{
// Unlikely to compare incorrect type so removed for performance
// if (!(obj.GetType() == typeof(GridPos)))
// return false;
GridPos p = (GridPos)obj;
if (ReferenceEquals(null, p))
{
return false;
}
// Return true if the fields match:
return (x == p.x) && (y == p.y);
}
public bool Equals(GridPos p)
{
if (ReferenceEquals(null, p))
{
return false;
}
// Return true if the fields match:
return (x == p.x) && (y == p.y);
}
public static bool operator ==(GridPos a, GridPos b)
{
// If both are null, or both are same instance, return true.
if (System.Object.ReferenceEquals(a, b))
{
return true;
}
if (ReferenceEquals(null, a))
{
return false;
}
if (ReferenceEquals(null, b))
{
return false;
}
// Return true if the fields match:
return a.x == b.x && a.y == b.y;
}
public static bool operator !=(GridPos a, GridPos b)
{
return !(a == b);
}
public GridPos Set(int iX, int iY)
{
this.x = iX;
this.y = iY;
return this;
}
public override string ToString()
{
return string.Format("({0},{1})", x, y);
}
}
}
================================================
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/GridRect.cs
================================================
/*!
@file GridRect.cs
@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>
<http://github.com/juhgiyo/eppathfinding.cs>
@date July 16, 2013
@brief GridRect Interface
@version 2.0
@section LICENSE
The MIT License (MIT)
Copyright (c) 2013 Woong Gyu La <juhgiyo@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@section DESCRIPTION
An Interface for the GridRect Struct.
*/
using System;
using System.Collections.Generic;
using System.Collections;
namespace EpPathFinding.cs
{
public class GridRect
{
public int minX;
public int minY;
public int maxX;
public int maxY;
public GridRect()
{
minX = 0;
minY = 0;
maxX = 0;
maxY = 0;
}
public GridRect(int iMinX, int iMinY, int iMaxX, int iMaxY)
{
minX = iMinX;
minY = iMinY;
maxX = iMaxX;
maxY = iMaxY;
}
public GridRect(GridRect b)
{
minX = b.minX;
minY = b.minY;
maxX = b.maxX;
maxY = b.maxY;
}
public override int GetHashCode()
{
return minX ^ minY ^ maxX ^ maxY;
}
public override bool Equals(System.Object obj)
{
// Unlikely to compare incorrect type so removed for performance
//if (!(obj.GetType() == typeof(GridRect)))
// return false;
GridRect p = (GridRect)obj;
if (ReferenceEquals(null, p))
{
return false;
}
// Return true if the fields match:
return (minX == p.minX) && (minY == p.minY) && (maxX == p.maxX) && (maxY == p.maxY);
}
public bool Equals(GridRect p)
{
if (ReferenceEquals(null, p))
{
return false;
}
// Return true if the fields match:
return (minX == p.minX) && (minY == p.minY) && (maxX == p.maxX) && (maxY == p.maxY);
}
public static bool operator ==(GridRect a, GridRect b)
{
// If both are null, or both are same instance, return true.
if (System.Object.ReferenceEquals(a, b))
{
return true;
}
if (ReferenceEquals(null, a))
{
return false;
}
if (ReferenceEquals(null, b))
{
return false;
}
// Return true if the fields match:
return (a.minX == b.minX) && (a.minY == b.minY) && (a.maxX == b.maxX) && (a.maxY == b.maxY);
}
public static bool operator !=(GridRect a, GridRect b)
{
return !(a == b);
}
public GridRect Set(int iMinX, int iMinY, int iMaxX, int iMaxY)
{
this.minX = iMinX;
this.minY = iMinY;
this.maxX = iMaxX;
this.maxY = iMaxY;
return this;
}
}
}
================================================
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/Heuristic.cs
================================================
/*!
@file Heuristic.cs
@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>
<http://github.com/juhgiyo/eppathfinding.cs>
@date July 16, 2013
@brief Heuristic Function Interface
@version 2.0
@section LICENSE
The MIT License (MIT)
Copyright (c) 2013 Woong Gyu La <juhgiyo@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@section DESCRIPTION
An Interface for the Heuristic Function Class.
*/
using System;
using System.Collections.Generic;
using System.Collections;
namespace EpPathFinding.cs
{
public enum HeuristicMode
{
MANHATTAN,
EUCLIDEAN,
CHEBYSHEV,
};
public class Heuristic
{
public static float Manhattan(int iDx, int iDy)
{
return (float)iDx + iDy;
}
public static float Euclidean(int iDx, int iDy)
{
float tFdx = (float)iDx;
float tFdy = (float)iDy;
return (float)Math.Sqrt((double)(tFdx * tFdx + tFdy * tFdy));
}
public static float Chebyshev(int iDx, int iDy)
{
return (float)Math.Max(iDx, iDy);
}
}
}
================================================
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/JumpPointFinder.cs
================================================
/*!
@file JumpPointFinder.cs
@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>
<http://github.com/juhgiyo/eppathfinding.cs>
@date July 16, 2013
@brief Jump Point Search Algorithm Interface
@version 2.0
@section LICENSE
The MIT License (MIT)
Copyright (c) 2013 Woong Gyu La <juhgiyo@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@section DESCRIPTION
An Interface for the Jump Point Search Algorithm Class.
*/
using C5;
using System;
using System.Collections.Generic;
using System.Collections;
namespace EpPathFinding.cs
{
public enum IterationType
{
LOOP,
RECURSIVE,
};
public enum EndNodeUnWalkableTreatment
{
ALLOW,
DISALLOW
};
public class JumpPointParam : ParamBase
{
[System.Obsolete("This constructor is deprecated, please use the Constructor with EndNodeUnWalkableTreatment and DiagonalMovement instead.")]
public JumpPointParam(BaseGrid iGrid, GridPos iStartPos, GridPos iEndPos, bool iAllowEndNodeUnWalkable = true, bool iCrossCorner = true, bool iCrossAdjacentPoint = true, HeuristicMode iMode = HeuristicMode.EUCLIDEAN)
:base(iGrid, iStartPos, iEndPos, Util.GetDiagonalMovement(iCrossCorner, iCrossAdjacentPoint), iMode)
{
CurEndNodeUnWalkableTreatment = iAllowEndNodeUnWalkable ? EndNodeUnWalkableTreatment.ALLOW : EndNodeUnWalkableTreatment.DISALLOW;
openList = new IntervalHeap<Node>();
CurIterationType = IterationType.LOOP;
}
[System.Obsolete("This constructor is deprecated, please use the Constructor with EndNodeUnWalkableTreatment and DiagonalMovement instead.")]
public JumpPointParam(BaseGrid iGrid, bool iAllowEndNodeUnWalkable = true, bool iCrossCorner = true, bool iCrossAdjacentPoint = true, HeuristicMode iMode = HeuristicMode.EUCLIDEAN)
: base(iGrid, Util.GetDiagonalMovement(iCrossCorner, iCrossAdjacentPoint), iMode)
{
CurEndNodeUnWalkableTreatment = iAllowEndNodeUnWalkable ? EndNodeUnWalkableTreatment.ALLOW : EndNodeUnWalkableTreatment.DISALLOW;
openList = new IntervalHeap<Node>();
CurIterationType = IterationType.LOOP;
}
[System.Obsolete("This constructor is deprecated, please use the Constructor with EndNodeUnWalkableTreatment and DiagonalMovement instead.")]
public JumpPointParam(BaseGrid iGrid, GridPos iStartPos, GridPos iEndPos, bool iAllowEndNodeUnWalkable = true, DiagonalMovement iDiagonalMovement= DiagonalMovement.Always, HeuristicMode iMode = HeuristicMode.EUCLIDEAN)
: base(iGrid,iStartPos,iEndPos, iDiagonalMovement, iMode)
{
CurEndNodeUnWalkableTreatment = iAllowEndNodeUnWalkable ? EndNodeUnWalkableTreatment.ALLOW : EndNodeUnWalkableTreatment.DISALLOW;
openList = new IntervalHeap<Node>();
CurIterationType = IterationType.LOOP;
}
[System.Obsolete("This constructor is deprecated, please use the Constructor with EndNodeUnWalkableTreatment and DiagonalMovement instead.")]
public JumpPointParam(BaseGrid iGrid, bool iAllowEndNodeUnWalkable = true, DiagonalMovement iDiagonalMovement= DiagonalMovement.Always, HeuristicMode iMode = HeuristicMode.EUCLIDEAN)
: base(iGrid, iDiagonalMovement, iMode)
{
CurEndNodeUnWalkableTreatment = iAllowEndNodeUnWalkable ? EndNodeUnWalkableTreatment.ALLOW : EndNodeUnWalkableTreatment.DISALLOW;
openList = new IntervalHeap<Node>();
CurIterationType = IterationType.LOOP;
}
public JumpPointParam(BaseGrid iGrid, GridPos iStartPos, GridPos iEndPos, EndNodeUnWalkableTreatment iAllowEndNodeUnWalkable = EndNodeUnWalkableTreatment.ALLOW, DiagonalMovement iDiagonalMovement = DiagonalMovement.Always, HeuristicMode iMode = HeuristicMode.EUCLIDEAN)
: base(iGrid, iStartPos, iEndPos, iDiagonalMovement, iMode)
{
CurEndNodeUnWalkableTreatment = iAllowEndNodeUnWalkable;
openList = new IntervalHeap<Node>();
CurIterationType = IterationType.LOOP;
}
public JumpPointParam(BaseGrid iGrid, EndNodeUnWalkableTreatment iAllowEndNodeUnWalkable = EndNodeUnWalkableTreatment.ALLOW, DiagonalMovement iDiagonalMovement = DiagonalMovement.Always, HeuristicMode iMode = HeuristicMode.EUCLIDEAN)
: base(iGrid, iDiagonalMovement, iMode)
{
CurEndNodeUnWalkableTreatment = iAllowEndNodeUnWalkable;
openList = new IntervalHeap<Node>();
CurIterationType = IterationType.LOOP;
}
public JumpPointParam(JumpPointParam b):base(b)
{
m_heuristic = b.m_heuristic;
CurEndNodeUnWalkableTreatment = b.CurEndNodeUnWalkableTreatment;
openList = new IntervalHeap<Node>();
openList.AddAll(b.openList);
CurIterationType = b.CurIterationType;
}
internal override void _reset(GridPos iStartPos, GridPos iEndPos, BaseGrid iSearchGrid = null)
{
openList = new IntervalHeap<Node>();
//openList.Clear();
}
[System.Obsolete("This property is deprecated, please use the CurEndNodeUnWalkableTreatment instead.")]
public bool AllowEndNodeUnWalkable
{
get
{
return CurEndNodeUnWalkableTreatment == EndNodeUnWalkableTreatment.ALLOW;
}
set
{
CurEndNodeUnWalkableTreatment = value ? EndNodeUnWalkableTreatment.ALLOW : EndNodeUnWalkableTreatment.DISALLOW;
}
}
[System.Obsolete("This property is deprecated, please use the CurIterationType instead.")]
public bool UseRecursive
{
get
{
return CurIterationType==IterationType.RECURSIVE;
}
set
{
CurIterationType = value ? IterationType.RECURSIVE : IterationType.LOOP;
}
}
public EndNodeUnWalkableTreatment CurEndNodeUnWalkableTreatment
{
get;
set;
}
public IterationType CurIterationType
{
get;
set;
}
//public List<Node> openList;
public IntervalHeap<Node> openList;
}
public class JumpPointFinder
{
public static List<GridPos> GetFullPath(List<GridPos> routeFound)
{
if (routeFound == null)
return null;
List<GridPos> consecutiveGridList = new List<GridPos>();
if (routeFound.Count > 1)
consecutiveGridList.Add(new GridPos(routeFound[0]));
for (int routeTrav = 0; routeTrav < routeFound.Count - 1; routeTrav++)
{
GridPos fromGrid = new GridPos(routeFound[routeTrav]);
GridPos toGrid = routeFound[routeTrav + 1];
int dX = toGrid.x - fromGrid.x;
int dY = toGrid.y - fromGrid.y;
int nDX = 0;
int nDY = 0;
if (dX != 0)
{
nDX = (dX / Math.Abs(dX));
}
if (dY != 0)
{
nDY = (dY / Math.Abs(dY));
}
while (fromGrid != toGrid)
{
fromGrid.x += nDX;
fromGrid.y += nDY;
consecutiveGridList.Add(new GridPos(fromGrid));
}
}
return consecutiveGridList;
}
public static List<GridPos> FindPath(JumpPointParam iParam)
{
IntervalHeap<Node> tOpenList = iParam.openList;
Node tStartNode = iParam.StartNode;
Node tEndNode = iParam.EndNode;
Node tNode;
bool revertEndNodeWalkable = false;
// set the `g` and `f` value of the start node to be 0
tStartNode.startToCurNodeLen = 0;
tStartNode.heuristicStartToEndLen = 0;
// push the start node into the open list
tOpenList.Add(tStartNode);
tStartNode.isOpened = true;
if (iParam.CurEndNodeUnWalkableTreatment == EndNodeUnWalkableTreatment.ALLOW && !iParam.SearchGrid.IsWalkableAt(tEndNode.x, tEndNode.y))
{
iParam.SearchGrid.SetWalkableAt(tEndNode.x, tEndNode.y, true);
revertEndNodeWalkable = true;
}
// while the open list is not empty
while (tOpenList.Count > 0)
{
// pop the position of node which has the minimum `f` value.
tNode = tOpenList.DeleteMin();
tNode.isClosed = true;
if (tNode.Equals(tEndNode))
{
if (revertEndNodeWalkable)
{
iParam.SearchGrid.SetWalkableAt(tEndNode.x, tEndNode.y, false);
}
return Node.Backtrace(tNode); // rebuilding path
}
identifySuccessors(iParam, tNode);
}
if (revertEndNodeWalkable)
{
iParam.SearchGrid.SetWalkableAt(tEndNode.x, tEndNode.y, false);
}
// fail to find the path
return new List<GridPos>();
}
private static void identifySuccessors(JumpPointParam iParam, Node iNode)
{
HeuristicDelegate tHeuristic = iParam.HeuristicFunc;
IntervalHeap<Node> tOpenList = iParam.openList;
int tEndX = iParam.EndNode.x;
int tEndY = iParam.EndNode.y;
GridPos tNeighbor;
GridPos tJumpPoint;
Node tJumpNode;
List<GridPos> tNeighbors = findNeighbors(iParam, iNode);
for (int i = 0; i < tNeighbors.Count; i++)
{
tNeighbor = tNeighbors[i];
if (iParam.CurIterationType==IterationType.RECURSIVE)
tJumpPoint = jump(iParam, tNeighbor.x, tNeighbor.y, iNode.x, iNode.y);
else
tJumpPoint = jumpLoop(iParam, tNeighbor.x, tNeighbor.y, iNode.x, iNode.y);
if (tJumpPoint != null)
{
tJumpNode = iParam.SearchGrid.GetNodeAt(tJumpPoint.x, tJumpPoint.y);
if (tJumpNode == null)
{
if (iParam.EndNode.x == tJumpPoint.x && iParam.EndNode.y == tJumpPoint.y)
tJumpNode = iParam.SearchGrid.GetNodeAt(tJumpPoint);
}
if (tJumpNode.isClosed)
{
continue;
}
// include distance, as parent may not be immediately adjacent:
float tCurNodeToJumpNodeLen = tHeuristic(Math.Abs(tJumpPoint.x - iNode.x), Math.Abs(tJumpPoint.y - iNode.y));
float tStartToJumpNodeLen = iNode.startToCurNodeLen + tCurNodeToJumpNodeLen; // next `startToCurNodeLen` value
if (!tJumpNode.isOpened || tStartToJumpNodeLen < tJumpNode.startToCurNodeLen)
{
tJumpNode.startToCurNodeLen = tStartToJumpNodeLen;
tJumpNode.heuristicCurNodeToEndLen = (tJumpNode.heuristicCurNodeToEndLen == null ? tHeuristic(Math.Abs(tJumpPoint.x - tEndX), Math.Abs(tJumpPoint.y - tEndY)) : tJumpNode.heuristicCurNodeToEndLen);
tJumpNode.heuristicStartToEndLen = tJumpNode.startToCurNodeLen + tJumpNode.heuristicCurNodeToEndLen.Value;
tJumpNode.parent = iNode;
if (!tJumpNode.isOpened)
{
tOpenList.Add(tJumpNode);
tJumpNode.isOpened = true;
}
}
}
}
}
private class JumpSnapshot
{
public int iX;
public int iY;
public int iPx;
public int iPy;
public int tDx;
public int tDy;
public int stage;
public JumpSnapshot()
{
iX = 0;
iY = 0;
iPx = 0;
iPy = 0;
tDx = 0;
tDy = 0;
stage = 0;
}
}
private static GridPos jumpLoop(JumpPointParam iParam, int iX, int iY, int iPx, int iPy)
{
GridPos retVal = null;
Stack<JumpSnapshot> stack = new Stack<JumpSnapshot>();
JumpSnapshot currentSnapshot = new JumpSnapshot();
JumpSnapshot newSnapshot = null;
currentSnapshot.iX = iX;
currentSnapshot.iY = iY;
currentSnapshot.iPx = iPx;
currentSnapshot.iPy = iPy;
currentSnapshot.stage = 0;
stack.Push(currentSnapshot);
while (stack.Count != 0)
{
currentSnapshot = stack.Pop();
switch (currentSnapshot.stage)
{
case 0:
if (!iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX, currentSnapshot.iY))
{
retVal = null;
continue;
}
else if (iParam.SearchGrid.GetNodeAt(currentSnapshot.iX, currentSnapshot.iY).Equals(iParam.EndNode))
{
retVal = new GridPos(currentSnapshot.iX, currentSnapshot.iY);
continue;
}
currentSnapshot.tDx = currentSnapshot.iX - currentSnapshot.iPx;
currentSnapshot.tDy = currentSnapshot.iY - currentSnapshot.iPy;
if (iParam.DiagonalMovement == DiagonalMovement.Always || iParam.DiagonalMovement == DiagonalMovement.IfAtLeastOneWalkable)
{
// check for forced neighbors
// along the diagonal
if (currentSnapshot.tDx != 0 && currentSnapshot.tDy != 0)
{
if ((iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX - currentSnapshot.tDx, currentSnapshot.iY + currentSnapshot.tDy) && !iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX - currentSnapshot.tDx, currentSnapshot.iY)) ||
(iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX + currentSnapshot.tDx, currentSnapshot.iY - currentSnapshot.tDy) && !iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX, currentSnapshot.iY - currentSnapshot.tDy)))
{
retVal = new GridPos(currentSnapshot.iX, currentSnapshot.iY);
continue;
}
}
// horizontally/vertically
else
{
if (currentSnapshot.tDx != 0)
{
// moving along x
if ((iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX + currentSnapshot.tDx, currentSnapshot.iY + 1) && !iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX, currentSnapshot.iY + 1)) ||
(iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX + currentSnapshot.tDx, currentSnapshot.iY - 1) && !iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX, currentSnapshot.iY - 1)))
{
retVal = new GridPos(currentSnapshot.iX, currentSnapshot.iY);
continue;
}
}
else
{
if ((iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX + 1, currentSnapshot.iY + currentSnapshot.tDy) && !iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX + 1, currentSnapshot.iY)) ||
(iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX - 1, currentSnapshot.iY + currentSnapshot.tDy) && !iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX - 1, currentSnapshot.iY)))
{
retVal = new GridPos(currentSnapshot.iX, currentSnapshot.iY);
continue;
}
}
}
// when moving diagonally, must check for vertical/horizontal jump points
if (currentSnapshot.tDx != 0 && currentSnapshot.tDy != 0)
{
currentSnapshot.stage = 1;
stack.Push(currentSnapshot);
newSnapshot = new JumpSnapshot();
newSnapshot.iX = currentSnapshot.iX + currentSnapshot.tDx;
newSnapshot.iY = currentSnapshot.iY;
newSnapshot.iPx = currentSnapshot.iX;
newSnapshot.iPy = currentSnapshot.iY;
newSnapshot.stage = 0;
stack.Push(newSnapshot);
continue;
}
// moving diagonally, must make sure one of the vertical/horizontal
// neighbors is open to allow the path
// moving diagonally, must make sure one of the vertical/horizontal
// neighbors is open to allow the path
if (iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX + currentSnapshot.tDx, currentSnapshot.iY) || iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX, currentSnapshot.iY + currentSnapshot.tDy))
{
newSnapshot = new JumpSnapshot();
newSnapshot.iX = currentSnapshot.iX + currentSnapshot.tDx;
newSnapshot.iY = currentSnapshot.iY + currentSnapshot.tDy;
newSnapshot.iPx = currentSnapshot.iX;
newSnapshot.iPy = currentSnapshot.iY;
newSnapshot.stage = 0;
stack.Push(newSnapshot);
continue;
}
else if (iParam.DiagonalMovement==DiagonalMovement.Always)
{
newSnapshot = new JumpSnapshot();
newSnapshot.iX = currentSnapshot.iX + currentSnapshot.tDx;
newSnapshot.iY = currentSnapshot.iY + currentSnapshot.tDy;
newSnapshot.iPx = currentSnapshot.iX;
newSnapshot.iPy = currentSnapshot.iY;
newSnapshot.stage = 0;
stack.Push(newSnapshot);
continue;
}
}
else if (iParam.DiagonalMovement == DiagonalMovement.OnlyWhenNoObstacles)
{
// check for forced neighbors
// along the diagonal
if (currentSnapshot.tDx != 0 && currentSnapshot.tDy != 0)
{
if ((iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX + currentSnapshot.tDx, currentSnapshot.iY + currentSnapshot.tDy) && iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX, currentSnapshot.iY + currentSnapshot.tDy) && !iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX + currentSnapshot.tDx, currentSnapshot.iY)) ||
(iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX + currentSnapshot.tDx, currentSnapshot.iY + currentSnapshot.tDy) && iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX + currentSnapshot.tDx, currentSnapshot.iY) && !iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX, currentSnapshot.iY + currentSnapshot.tDy)))
{
retVal = new GridPos(currentSnapshot.iX, currentSnapshot.iY);
continue;
}
}
// horizontally/vertically
else
{
if (currentSnapshot.tDx != 0)
{
// moving along x
if ((iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX, currentSnapshot.iY + 1) && !iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX - currentSnapshot.tDx, currentSnapshot.iY + 1)) ||
(iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX, currentSnapshot.iY - 1) && !iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX - currentSnapshot.tDx, currentSnapshot.iY - 1)))
{
retVal = new GridPos(currentSnapshot.iX, currentSnapshot.iY);
continue;
}
}
else
{
if ((iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX + 1, currentSnapshot.iY) && !iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX + 1, currentSnapshot.iY - currentSnapshot.tDy)) ||
(iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX - 1, currentSnapshot.iY) && !iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX - 1, currentSnapshot.iY - currentSnapshot.tDy)))
{
retVal = new GridPos(currentSnapshot.iX, currentSnapshot.iY);
continue;
}
}
}
// when moving diagonally, must check for vertical/horizontal jump points
if (currentSnapshot.tDx != 0 && currentSnapshot.tDy != 0)
{
currentSnapshot.stage = 3;
stack.Push(currentSnapshot);
newSnapshot = new JumpSnapshot();
newSnapshot.iX = currentSnapshot.iX + currentSnapshot.tDx;
newSnapshot.iY = currentSnapshot.iY;
newSnapshot.iPx = currentSnapshot.iX;
newSnapshot.iPy = currentSnapshot.iY;
newSnapshot.stage = 0;
stack.Push(newSnapshot);
continue;
}
// moving diagonally, must make sure both of the vertical/horizontal
// neighbors is open to allow the path
if (iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX + currentSnapshot.tDx, currentSnapshot.iY) && iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX, currentSnapshot.iY + currentSnapshot.tDy))
{
newSnapshot = new JumpSnapshot();
newSnapshot.iX = currentSnapshot.iX + currentSnapshot.tDx;
newSnapshot.iY = currentSnapshot.iY + currentSnapshot.tDy;
newSnapshot.iPx = currentSnapshot.iX;
newSnapshot.iPy = currentSnapshot.iY;
newSnapshot.stage = 0;
stack.Push(newSnapshot);
continue;
}
}
else // if(iParam.DiagonalMovement == DiagonalMovement.Never)
{
if (currentSnapshot.tDx != 0)
{
// moving along x
if (!iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX + currentSnapshot.tDx, currentSnapshot.iY))
{
retVal= new GridPos(iX, iY);
continue;
}
}
else
{
if (!iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX, currentSnapshot.iY + currentSnapshot.tDy))
{
retVal = new GridPos(iX, iY);
continue;
}
}
// must check for perpendicular jump points
if (currentSnapshot.tDx != 0)
{
currentSnapshot.stage = 5;
stack.Push(currentSnapshot);
newSnapshot = new JumpSnapshot();
newSnapshot.iX = currentSnapshot.iX;
newSnapshot.iY = currentSnapshot.iY + 1;
newSnapshot.iPx = currentSnapshot.iX;
newSnapshot.iPy = currentSnapshot.iY;
newSnapshot.stage = 0;
stack.Push(newSnapshot);
continue;
}
else // tDy != 0
{
currentSnapshot.stage = 6;
stack.Push(currentSnapshot);
newSnapshot = new JumpSnapshot();
newSnapshot.iX = currentSnapshot.iX + 1;
newSnapshot.iY = currentSnapshot.iY;
newSnapshot.iPx = currentSnapshot.iX;
newSnapshot.iPy = currentSnapshot.iY;
newSnapshot.stage = 0;
stack.Push(newSnapshot);
continue;
}
}
retVal = null;
break;
case 1:
if (retVal != null)
{
retVal = new GridPos(currentSnapshot.iX, currentSnapshot.iY);
continue;
}
currentSnapshot.stage = 2;
stack.Push(currentSnapshot);
newSnapshot = new JumpSnapshot();
newSnapshot.iX = currentSnapshot.iX;
newSnapshot.iY = currentSnapshot.iY + currentSnapshot.tDy;
newSnapshot.iPx = currentSnapshot.iX;
newSnapshot.iPy = currentSnapshot.iY;
newSnapshot.stage = 0;
stack.Push(newSnapshot);
break;
case 2:
if (retVal != null)
{
retVal = new GridPos(currentSnapshot.iX, currentSnapshot.iY);
continue;
}
// moving diagonally, must make sure one of the vertical/horizontal
// neighbors is open to allow the path
if (iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX + currentSnapshot.tDx, currentSnapshot.iY) || iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX, currentSnapshot.iY + currentSnapshot.tDy))
{
newSnapshot = new JumpSnapshot();
newSnapshot.iX = currentSnapshot.iX + currentSnapshot.tDx;
newSnapshot.iY = currentSnapshot.iY + currentSnapshot.tDy;
newSnapshot.iPx = currentSnapshot.iX;
newSnapshot.iPy = currentSnapshot.iY;
newSnapshot.stage = 0;
stack.Push(newSnapshot);
continue;
}
else if (iParam.DiagonalMovement==DiagonalMovement.Always)
{
newSnapshot = new JumpSnapshot();
newSnapshot.iX = currentSnapshot.iX + currentSnapshot.tDx;
newSnapshot.iY = currentSnapshot.iY + currentSnapshot.tDy;
newSnapshot.iPx = currentSnapshot.iX;
newSnapshot.iPy = currentSnapshot.iY;
newSnapshot.stage = 0;
stack.Push(newSnapshot);
continue;
}
retVal = null;
break;
case 3:
if (retVal != null)
{
retVal = new GridPos(currentSnapshot.iX, currentSnapshot.iY);
continue;
}
currentSnapshot.stage = 4;
stack.Push(currentSnapshot);
newSnapshot = new JumpSnapshot();
newSnapshot.iX = currentSnapshot.iX;
newSnapshot.iY = currentSnapshot.iY + currentSnapshot.tDy;
newSnapshot.iPx = currentSnapshot.iX;
newSnapshot.iPy = currentSnapshot.iY;
newSnapshot.stage = 0;
stack.Push(newSnapshot);
break;
case 4:
if (retVal != null)
{
retVal = new GridPos(currentSnapshot.iX, currentSnapshot.iY);
continue;
}
// moving diagonally, must make sure both of the vertical/horizontal
// neighbors is open to allow the path
if (iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX + currentSnapshot.tDx, currentSnapshot.iY) && iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX, currentSnapshot.iY + currentSnapshot.tDy))
{
newSnapshot = new JumpSnapshot();
newSnapshot.iX = currentSnapshot.iX + currentSnapshot.tDx;
newSnapshot.iY = currentSnapshot.iY + currentSnapshot.tDy;
newSnapshot.iPx = currentSnapshot.iX;
newSnapshot.iPy = currentSnapshot.iY;
newSnapshot.stage = 0;
stack.Push(newSnapshot);
continue;
}
retVal = null;
break;
case 5:
if (retVal != null)
{
retVal = new GridPos(currentSnapshot.iX, currentSnapshot.iY);
continue;
}
currentSnapshot.stage = 7;
stack.Push(currentSnapshot);
newSnapshot = new JumpSnapshot();
newSnapshot.iX = currentSnapshot.iX;
newSnapshot.iY = currentSnapshot.iY - 1;
newSnapshot.iPx = currentSnapshot.iX;
newSnapshot.iPy = currentSnapshot.iY;
newSnapshot.stage = 0;
stack.Push(newSnapshot);
break;
case 6:
if (retVal != null)
{
retVal = new GridPos(currentSnapshot.iX, currentSnapshot.iY);
continue;
}
currentSnapshot.stage = 7;
stack.Push(currentSnapshot);
newSnapshot = new JumpSnapshot();
newSnapshot.iX = currentSnapshot.iX - 1;
newSnapshot.iY = currentSnapshot.iY;
newSnapshot.iPx = currentSnapshot.iX;
newSnapshot.iPy = currentSnapshot.iY;
newSnapshot.stage = 0;
stack.Push(newSnapshot);
break;
case 7:
if (retVal != null)
{
retVal = new GridPos(currentSnapshot.iX, currentSnapshot.iY);
continue;
}
// keep going
if (iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX + currentSnapshot.tDx, currentSnapshot.iY) && iParam.SearchGrid.IsWalkableAt(currentSnapshot.iX, currentSnapshot.iY + currentSnapshot.tDy))
{
newSnapshot = new JumpSnapshot();
newSnapshot.iX = currentSnapshot.iX + currentSnapshot.tDx;
newSnapshot.iY = currentSnapshot.iY + currentSnapshot.tDy;
newSnapshot.iPx = currentSnapshot.iX;
newSnapshot.iPy = currentSnapshot.iY;
newSnapshot.stage = 0;
stack.Push(newSnapshot);
continue;
}
retVal = null;
break;
}
}
return retVal;
}
private static GridPos jump(JumpPointParam iParam, int iX, int iY, int iPx, int iPy)
{
if (!iParam.SearchGrid.IsWalkableAt(iX, iY))
{
return null;
}
else if (iParam.SearchGrid.GetNodeAt(iX, iY).Equals(iParam.EndNode))
{
return new GridPos(iX, iY);
}
int tDx = iX - iPx;
int tDy = iY - iPy;
if (iParam.DiagonalMovement == DiagonalMovement.Always || iParam.DiagonalMovement == DiagonalMovement.IfAtLeastOneWalkable)
{
// check for forced neighbors
// along the diagonal
if (tDx != 0 && tDy != 0)
{
if ((iParam.SearchGrid.IsWalkableAt(iX - tDx, iY + tDy) && !iParam.SearchGrid.IsWalkableAt(iX - tDx, iY)) ||
(iParam.SearchGrid.IsWalkableAt(iX + tDx, iY - tDy) && !iParam.SearchGrid.IsWalkableAt(iX, iY - tDy)))
{
return new GridPos(iX, iY);
}
}
// horizontally/vertically
else
{
if (tDx != 0)
{
// moving along x
if ((iParam.SearchGrid.IsWalkableAt(iX + tDx, iY + 1) && !iParam.SearchGrid.IsWalkableAt(iX, iY + 1)) ||
(iParam.SearchGrid.IsWalkableAt(iX + tDx, iY - 1) && !iParam.SearchGrid.IsWalkableAt(iX, iY - 1)))
{
return new GridPos(iX, iY);
}
}
else
{
if ((iParam.SearchGrid.IsWalkableAt(iX + 1, iY + tDy) && !iParam.SearchGrid.IsWalkableAt(iX + 1, iY)) ||
(iParam.SearchGrid.IsWalkableAt(iX - 1, iY + tDy) && !iParam.SearchGrid.IsWalkableAt(iX - 1, iY)))
{
return new GridPos(iX, iY);
}
}
}
// when moving diagonally, must check for vertical/horizontal jump points
if (tDx != 0 && tDy != 0)
{
if (jump(iParam, iX + tDx, iY, iX, iY) != null)
{
return new GridPos(iX, iY);
}
if (jump(iParam, iX, iY + tDy, iX, iY) != null)
{
return new GridPos(iX, iY);
}
}
// moving diagonally, must make sure one of the vertical/horizontal
// neighbors is open to allow the path
if (iParam.SearchGrid.IsWalkableAt(iX + tDx, iY) || iParam.SearchGrid.IsWalkableAt(iX, iY + tDy))
{
return jump(iParam, iX + tDx, iY + tDy, iX, iY);
}
else if (iParam.DiagonalMovement == DiagonalMovement.Always)
{
return jump(iParam, iX + tDx, iY + tDy, iX, iY);
}
else
{
return null;
}
}
else if (iParam.DiagonalMovement == DiagonalMovement.OnlyWhenNoObstacles)
{
// check for forced neighbors
// along the diagonal
if (tDx != 0 && tDy != 0)
{
if (iParam.SearchGrid.IsWalkableAt(iX + tDx, iY + tDy) && ( !iParam.SearchGrid.IsWalkableAt(iX, iY + tDy) || !iParam.SearchGrid.IsWalkableAt(iX + tDx, iY)))
{
return new GridPos(iX, iY);
}
}
// horizontally/vertically
else
{
if (tDx != 0)
{
// moving along x
if ((iParam.SearchGrid.IsWalkableAt(iX, iY + 1) && !iParam.SearchGrid.IsWalkableAt(iX - tDx, iY + 1)) ||
(iParam.SearchGrid.IsWalkableAt(iX, iY - 1) && !iParam.SearchGrid.IsWalkableAt(iX - tDx, iY - 1)))
{
return new GridPos(iX, iY);
}
}
else
{
if ((iParam.SearchGrid.IsWalkableAt(iX + 1, iY) && !iParam.SearchGrid.IsWalkableAt(iX + 1, iY - tDy)) ||
(iParam.SearchGrid.IsWalkableAt(iX - 1, iY) && !iParam.SearchGrid.IsWalkableAt(iX - 1, iY - tDy)))
{
return new GridPos(iX, iY);
}
}
}
// when moving diagonally, must check for vertical/horizontal jump points
if (tDx != 0 && tDy != 0)
{
if (jump(iParam, iX + tDx, iY, iX, iY) != null) return new GridPos(iX, iY);
if (jump(iParam, iX, iY + tDy, iX, iY) != null) return new GridPos(iX, iY);
}
// moving diagonally, must make sure both of the vertical/horizontal
// neighbors is open to allow the path
if (iParam.SearchGrid.IsWalkableAt(iX + tDx, iY) && iParam.SearchGrid.IsWalkableAt(iX, iY + tDy))
{
return jump(iParam, iX + tDx, iY + tDy, iX, iY);
}
else
{
return null;
}
}
else // if(iParam.DiagonalMovement == DiagonalMovement.Never)
{
if (tDx != 0)
{
// moving along x
if (!iParam.SearchGrid.IsWalkableAt(iX + tDx, iY))
{
return new GridPos(iX, iY);
}
}
else
{
if (!iParam.SearchGrid.IsWalkableAt(iX, iY + tDy))
{
return new GridPos(iX, iY);
}
}
// must check for perpendicular jump points
if (tDx != 0 )
{
if (jump(iParam, iX, iY + 1, iX, iY) != null) return new GridPos(iX, iY);
if (jump(iParam, iX, iY - 1, iX, iY) != null) return new GridPos(iX, iY);
}
else // tDy != 0
{
if (jump(iParam, iX + 1, iY, iX, iY) != null) return new GridPos(iX, iY);
if (jump(iParam, iX - 1, iY, iX, iY) != null) return new GridPos(iX, iY);
}
// keep going
if (iParam.SearchGrid.IsWalkableAt(iX + tDx, iY) && iParam.SearchGrid.IsWalkableAt(iX, iY + tDy))
{
return jump(iParam, iX + tDx, iY + tDy, iX, iY);
}
else
{
return null;
}
}
}
private static List<GridPos> findNeighbors(JumpPointParam iParam, Node iNode)
{
Node tParent = (Node)iNode.parent;
//var diagonalMovement = Util.GetDiagonalMovement(iParam.CrossCorner, iParam.CrossAdjacentPoint);
int tX = iNode.x;
int tY = iNode.y;
int tPx, tPy, tDx, tDy;
List<GridPos> tNeighbors = new List<GridPos>();
List<Node> tNeighborNodes;
Node tNeighborNode;
// directed pruning: can ignore most neighbors, unless forced.
if (tParent != null)
{
tPx = tParent.x;
tPy = tParent.y;
// get the normalized direction of travel
tDx = (tX - tPx) / Math.Max(Math.Abs(tX - tPx), 1);
tDy = (tY - tPy) / Math.Max(Math.Abs(tY - tPy), 1);
if (iParam.DiagonalMovement == DiagonalMovement.Always || iParam.DiagonalMovement == DiagonalMovement.IfAtLeastOneWalkable)
{
// search diagonally
if (tDx != 0 && tDy != 0)
{
if (iParam.SearchGrid.IsWalkableAt(tX, tY + tDy))
{
tNeighbors.Add(new GridPos(tX, tY + tDy));
}
if (iParam.SearchGrid.IsWalkableAt(tX + tDx, tY))
{
tNeighbors.Add(new GridPos(tX + tDx, tY));
}
if (iParam.SearchGrid.IsWalkableAt(tX + tDx, tY + tDy))
{
if (iParam.SearchGrid.IsWalkableAt(tX, tY + tDy) || iParam.SearchGrid.IsWalkableAt(tX + tDx, tY))
{
tNeighbors.Add(new GridPos(tX + tDx, tY + tDy));
}
else if (iParam.DiagonalMovement == DiagonalMovement.Always)
{
tNeighbors.Add(new GridPos(tX + tDx, tY + tDy));
}
}
if (iParam.SearchGrid.IsWalkableAt(tX - tDx, tY + tDy) && !iParam.SearchGrid.IsWalkableAt(tX - tDx, tY))
{
if (iParam.SearchGrid.IsWalkableAt(tX, tY + tDy))
{
tNeighbors.Add(new GridPos(tX - tDx, tY + tDy));
}
else if (iParam.DiagonalMovement == DiagonalMovement.Always)
{
tNeighbors.Add(new GridPos(tX - tDx, tY + tDy));
}
}
if (iParam.SearchGrid.IsWalkableAt(tX + tDx, tY - tDy) && !iParam.SearchGrid.IsWalkableAt(tX, tY - tDy))
{
if (iParam.SearchGrid.IsWalkableAt(tX + tDx, tY))
{
tNeighbors.Add(new GridPos(tX + tDx, tY - tDy));
}
else if (iParam.DiagonalMovement == DiagonalMovement.Always)
{
tNeighbors.Add(new GridPos(tX + tDx, tY - tDy));
}
}
}
// search horizontally/vertically
else
{
if (tDx != 0)
{
if (iParam.SearchGrid.IsWalkableAt(tX + tDx, tY))
{
tNeighbors.Add(new GridPos(tX + tDx, tY));
if (iParam.SearchGrid.IsWalkableAt(tX + tDx, tY + 1) && !iParam.SearchGrid.IsWalkableAt(tX, tY + 1))
{
tNeighbors.Add(new GridPos(tX + tDx, tY + 1));
}
if (iParam.SearchGrid.IsWalkableAt(tX + tDx, tY - 1) && !iParam.SearchGrid.IsWalkableAt(tX, tY - 1))
{
tNeighbors.Add(new GridPos(tX + tDx, tY - 1));
}
}
else if (iParam.DiagonalMovement == DiagonalMovement.Always)
{
if (iParam.SearchGrid.IsWalkableAt(tX + tDx, tY + 1) && !iParam.SearchGrid.IsWalkableAt(tX, tY + 1))
{
tNeighbors.Add(new GridPos(tX + tDx, tY + 1));
}
if (iParam.SearchGrid.IsWalkableAt(tX + tDx, tY - 1) && !iParam.SearchGrid.IsWalkableAt(tX, tY - 1))
{
tNeighbors.Add(new GridPos(tX + tDx, tY - 1));
}
}
}
else
{
if (iParam.SearchGrid.IsWalkableAt(tX, tY + tDy))
{
tNeighbors.Add(new GridPos(tX, tY + tDy));
if (iParam.SearchGrid.IsWalkableAt(tX + 1, tY + tDy) && !iParam.SearchGrid.IsWalkableAt(tX + 1, tY))
{
tNeighbors.Add(new GridPos(tX + 1, tY + tDy));
}
if (iParam.SearchGrid.IsWalkableAt(tX - 1, tY + tDy) && !iParam.SearchGrid.IsWalkableAt(tX - 1, tY))
{
tNeighbors.Add(new GridPos(tX - 1, tY + tDy));
}
}
else if (iParam.DiagonalMovement == DiagonalMovement.Always)
{
if (iParam.SearchGrid.IsWalkableAt(tX + 1, tY + tDy) && !iParam.SearchGrid.IsWalkableAt(tX + 1, tY))
{
tNeighbors.Add(new GridPos(tX + 1, tY + tDy));
}
if (iParam.SearchGrid.IsWalkableAt(tX - 1, tY + tDy) && !iParam.SearchGrid.IsWalkableAt(tX - 1, tY))
{
tNeighbors.Add(new GridPos(tX - 1, tY + tDy));
}
}
}
}
}
else if (iParam.DiagonalMovement == DiagonalMovement.OnlyWhenNoObstacles)
{
// search diagonally
if (tDx != 0 && tDy != 0)
{
if (iParam.SearchGrid.IsWalkableAt(tX, tY + tDy))
{
tNeighbors.Add(new GridPos(tX, tY + tDy));
}
if (iParam.SearchGrid.IsWalkableAt(tX + tDx, tY))
{
tNeighbors.Add(new GridPos(tX + tDx, tY));
}
if (iParam.SearchGrid.IsWalkableAt(tX + tDx, tY + tDy))
{
if (iParam.SearchGrid.IsWalkableAt(tX, tY + tDy) && iParam.SearchGrid.IsWalkableAt(tX + tDx, tY))
tNeighbors.Add(new GridPos(tX + tDx, tY + tDy));
}
if (iParam.SearchGrid.IsWalkableAt(tX - tDx, tY + tDy))
{
if (iParam.SearchGrid.IsWalkableAt(tX, tY + tDy) && iParam.SearchGrid.IsWalkableAt(tX - tDx, tY))
tNeighbors.Add(new GridPos(tX - tDx, tY + tDy));
}
if (iParam.SearchGrid.IsWalkableAt(tX + tDx, tY - tDy))
{
if (iParam.SearchGrid.IsWalkableAt(tX, tY - tDy) && iParam.SearchGrid.IsWalkableAt(tX + tDx, tY))
tNeighbors.Add(new GridPos(tX + tDx, tY - tDy));
}
}
// search horizontally/vertically
else
{
if (tDx != 0)
{
if (iParam.SearchGrid.IsWalkableAt(tX + tDx, tY))
{
tNeighbors.Add(new GridPos(tX + tDx, tY));
if (iParam.SearchGrid.IsWalkableAt(tX + tDx, tY + 1) && iParam.SearchGrid.IsWalkableAt(tX, tY + 1))
{
tNeighbors.Add(new GridPos(tX + tDx, tY + 1));
}
if (iParam.SearchGrid.IsWalkableAt(tX + tDx, tY - 1) && iParam.SearchGrid.IsWalkableAt(tX, tY - 1))
{
tNeighbors.Add(new GridPos(tX + tDx, tY - 1));
}
}
if (iParam.SearchGrid.IsWalkableAt(tX, tY + 1))
tNeighbors.Add(new GridPos(tX, tY + 1));
if (iParam.SearchGrid.IsWalkableAt(tX, tY - 1))
tNeighbors.Add(new GridPos(tX, tY - 1));
}
else
{
if (iParam.SearchGrid.IsWalkableAt(tX, tY + tDy))
{
tNeighbors.Add(new GridPos(tX, tY + tDy));
if (iParam.SearchGrid.IsWalkableAt(tX + 1, tY + tDy) && iParam.SearchGrid.IsWalkableAt(tX + 1, tY))
{
tNeighbors.Add(new GridPos(tX + 1, tY + tDy));
}
if (iParam.SearchGrid.IsWalkableAt(tX - 1, tY + tDy) && iParam.SearchGrid.IsWalkableAt(tX - 1, tY))
{
tNeighbors.Add(new GridPos(tX - 1, tY + tDy));
}
}
if (iParam.SearchGrid.IsWalkableAt(tX + 1, tY))
tNeighbors.Add(new GridPos(tX + 1, tY));
if (iParam.SearchGrid.IsWalkableAt(tX - 1, tY))
tNeighbors.Add(new GridPos(tX - 1, tY));
}
}
}
else // if(iParam.DiagonalMovement == DiagonalMovement.Never)
{
if (tDx != 0)
{
if (iParam.SearchGrid.IsWalkableAt(tX + tDx, tY))
{
tNeighbors.Add(new GridPos(tX + tDx, tY));
}
if (iParam.SearchGrid.IsWalkableAt(tX, tY + 1))
{
tNeighbors.Add(new GridPos(tX, tY +1));
}
if (iParam.SearchGrid.IsWalkableAt(tX, tY - 1))
{
tNeighbors.Add(new GridPos(tX, tY - 1));
}
}
else // if (tDy != 0)
{
if (iParam.SearchGrid.IsWalkableAt(tX, tY +tDy))
{
tNeighbors.Add(new GridPos(tX, tY + tDy));
}
if (iParam.SearchGrid.IsWalkableAt(tX + 1, tY))
{
tNeighbors.Add(new GridPos(tX + 1, tY));
}
if (iParam.SearchGrid.IsWalkableAt(tX - 1, tY))
{
tNeighbors.Add(new GridPos(tX - 1, tY));
}
}
}
}
// return all neighbors
else
{
tNeighborNodes = iParam.SearchGrid.GetNeighbors(iNode, iParam.DiagonalMovement);
for (int i = 0; i < tNeighborNodes.Count; i++)
{
tNeighborNode = tNeighborNodes[i];
tNeighbors.Add(new GridPos(tNeighborNode.x, tNeighborNode.y));
}
}
return tNeighbors;
}
}
}
================================================
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/NodePool.cs
================================================
/*!
@file NodePool.cs
@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>
<http://github.com/juhgiyo/eppathfinding.cs>
@date July 16, 2013
@brief NodePool Interface
@version 2.0
@section LICENSE
The MIT License (MIT)
Copyright (c) 2013 Woong Gyu La <juhgiyo@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@section DESCRIPTION
An Interface for the NodePool Class.
*/
using System;
using System.Collections.Generic;
using System.Collections;
namespace EpPathFinding.cs
{
public class NodePool
{
protected Dictionary<GridPos, Node> m_nodes;
public NodePool()
{
m_nodes = new Dictionary<GridPos, Node>();
}
public Dictionary<GridPos, Node> Nodes
{
get { return m_nodes; }
}
public Node GetNode(int iX, int iY)
{
GridPos pos = new GridPos(iX, iY);
return GetNode(pos);
}
public Node GetNode(GridPos iPos)
{
Node retVal = null;
m_nodes.TryGetValue(iPos, out retVal);
return retVal;
}
public Node SetNode(int iX, int iY, bool? iWalkable = null)
{
GridPos pos = new GridPos(iX, iY);
return SetNode(pos, iWalkable);
}
public Node SetNode(GridPos iPos, bool? iWalkable = null)
{
if (iWalkable.HasValue)
{
if (iWalkable.Value == true)
{
Node retVal = null;
if (m_nodes.TryGetValue(iPos, out retVal))
{
return retVal;
}
Node newNode = new Node(iPos.x, iPos.y, iWalkable);
m_nodes.Add(iPos, newNode);
return newNode;
}
else
{
removeNode(iPos);
}
}
else
{
Node newNode = new Node(iPos.x, iPos.y, true);
m_nodes.Add(iPos, newNode);
return newNode;
}
return null;
}
protected void removeNode(int iX, int iY)
{
GridPos pos = new GridPos(iX, iY);
removeNode(pos);
}
protected void removeNode(GridPos iPos)
{
if (m_nodes.ContainsKey(iPos))
m_nodes.Remove(iPos);
}
}
}
================================================
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/ParamBase.cs
================================================
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace EpPathFinding.cs
{
public delegate float HeuristicDelegate(int iDx, int iDy);
public abstract class ParamBase
{
public ParamBase(BaseGrid iGrid, GridPos iStartPos, GridPos iEndPos, DiagonalMovement iDiagonalMovement, HeuristicMode iMode) : this(iGrid, iDiagonalMovement, iMode)
{
m_startNode = m_searchGrid.GetNodeAt(iStartPos.x, iStartPos.y);
m_endNode = m_searchGrid.GetNodeAt(iEndPos.x, iEndPos.y);
if (m_startNode == null)
m_startNode = new Node(iStartPos.x, iStartPos.y, true);
if (m_endNode == null)
m_endNode = new Node(iEndPos.x, iEndPos.y, true);
}
public ParamBase(BaseGrid iGrid, DiagonalMovement iDiagonalMovement, HeuristicMode iMode)
{
SetHeuristic(iMode);
m_searchGrid = iGrid;
DiagonalMovement = iDiagonalMovement;
m_startNode = null;
m_endNode = null;
}
public ParamBase(ParamBase param)
{
m_searchGrid = param.m_searchGrid;
DiagonalMovement = param.DiagonalMovement;
m_startNode = param.m_startNode;
m_endNode = param.m_endNode;
}
internal abstract void _reset(GridPos iStartPos, GridPos iEndPos, BaseGrid iSearchGrid = null);
public void Reset(GridPos iStartPos, GridPos iEndPos, BaseGrid iSearchGrid = null)
{
_reset(iStartPos, iEndPos, iSearchGrid);
m_startNode = null;
m_endNode = null;
if (iSearchGrid != null)
m_searchGrid = iSearchGrid;
m_searchGrid.Reset();
m_startNode = m_searchGrid.GetNodeAt(iStartPos.x, iStartPos.y);
m_endNode = m_searchGrid.GetNodeAt(iEndPos.x, iEndPos.y);
if (m_startNode == null)
m_startNode = new Node(iStartPos.x, iStartPos.y, true);
if (m_endNode == null)
m_endNode = new Node(iEndPos.x, iEndPos.y, true);
}
public DiagonalMovement DiagonalMovement;
public HeuristicDelegate HeuristicFunc
{
get
{
return m_heuristic;
}
}
public BaseGrid SearchGrid
{
get
{
return m_searchGrid;
}
}
public Node StartNode
{
get
{
return m_startNode;
}
}
public Node EndNode
{
get
{
return m_endNode;
}
}
public void SetHeuristic(HeuristicMode iMode)
{
m_heuristic = null;
switch (iMode)
{
case HeuristicMode.MANHATTAN:
m_heuristic = new HeuristicDelegate(Heuristic.Manhattan);
break;
case HeuristicMode.EUCLIDEAN:
m_heuristic = new HeuristicDelegate(Heuristic.Euclidean);
break;
case HeuristicMode.CHEBYSHEV:
m_heuristic = new HeuristicDelegate(Heuristic.Chebyshev);
break;
default:
m_heuristic = new HeuristicDelegate(Heuristic.Euclidean);
break;
}
}
protected BaseGrid m_searchGrid;
protected Node m_startNode;
protected Node m_endNode;
protected HeuristicDelegate m_heuristic;
}
}
================================================
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/Util.cs
================================================
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace EpPathFinding.cs
{
public class Util
{
public static DiagonalMovement GetDiagonalMovement(bool iCrossCorners, bool iCrossAdjacentPoint)
{
if (iCrossCorners && iCrossAdjacentPoint)
{
return DiagonalMovement.Always;
}
else if (iCrossCorners)
{
return DiagonalMovement.IfAtLeastOneWalkable;
}
else
{
return DiagonalMovement.OnlyWhenNoObstacles;
}
}
}
}
================================================
FILE: EpPathFinding.cs/EpPathFinding.cs/Properties/AssemblyInfo.cs
================================================
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("EpPathFinding.cs")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("EpPathFinding.cs")]
[assembly: AssemblyCopyright("Copyright © 2016")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("2ad88772-7442-4978-b4e1-df1a2e0ded77")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
================================================
FILE: EpPathFinding.cs/EpPathFinding.cs/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
<package id="C5" version="2.4.5947.17249" targetFramework="net40" />
</packages>
================================================
FILE: EpPathFinding.cs/EpPathFinding.cs.sln
================================================
Microsoft Visual Studio Solution File, Format Version 11.00
# Visual Studio 2010
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "EpPathFinding.cs", "EpPathFinding.cs\EpPathFinding.cs.csproj", "{4BC2B4B0-2A38-4274-98A2-37CEF5F03B42}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Release|Any CPU = Release|Any CPU
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{4BC2B4B0-2A38-4274-98A2-37CEF5F03B42}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{4BC2B4B0-2A38-4274-98A2-37CEF5F03B42}.Debug|Any CPU.Build.0 = Debug|Any CPU
{4BC2B4B0-2A38-4274-98A2-37CEF5F03B42}.Release|Any CPU.ActiveCfg = Release|Any CPU
{4BC2B4B0-2A38-4274-98A2-37CEF5F03B42}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal
================================================
FILE: EpPathFindingDemo/EpPathFindingDemo.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">x86</Platform>
<ProductVersion>8.0.30703</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{82FE700A-0BA3-49D0-ACE0-C1F87FBE5021}</ProjectGuid>
<OutputType>WinExe</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>PathTest2010</RootNamespace>
<AssemblyName>PathTest2010</AssemblyName>
<TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
<TargetFrameworkProfile>Client</TargetFrameworkProfile>
<FileAlignment>512</FileAlignment>
<PublishUrl>publish\</PublishUrl>
<Install>true</Install>
<InstallFrom>Disk</InstallFrom>
<UpdateEnabled>false</UpdateEnabled>
<UpdateMode>Foreground</UpdateMode>
<UpdateInterval>7</UpdateInterval>
<UpdateIntervalUnits>Days</UpdateIntervalUnits>
<UpdatePeriodically>false</UpdatePeriodically>
<UpdateRequired>false</UpdateRequired>
<MapFileExtensions>true</MapFileExtensions>
<ApplicationRevision>0</ApplicationRevision>
<ApplicationVersion>1.0.0.%2a</ApplicationVersion>
<IsWebBootstrapper>false</IsWebBootstrapper>
<UseApplicationTrust>false</UseApplicationTrust>
<BootstrapperEnabled>true</BootstrapperEnabled>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
<PlatformTarget>x86</PlatformTarget>
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
<PlatformTarget>x86</PlatformTarget>
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<Reference Include="System.Core" />
<Reference Include="System.Xml.Linq" />
<Reference Include="System.Data.DataSetExtensions" />
<Reference Include="Microsoft.CSharp" />
<Reference Include="System.Data" />
<Reference Include="System.Deployment" />
<Reference Include="System.Drawing" />
<Reference Include="System.Windows.Forms" />
<Reference Include="System.Xml" />
</ItemGroup>
<ItemGroup>
<Compile Include="General\SingletonHolder.cs" />
<Compile Include="SearchGridForm.cs">
<SubType>Form</SubType>
</Compile>
<Compile Include="SearchGridForm.Designer.cs">
<DependentUpon>SearchGridForm.cs</DependentUpon>
</Compile>
<Compile Include="GridBox.cs" />
<Compile Include="GridLine.cs" />
<Compile Include="Program.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="ResultBox.cs" />
<EmbeddedResource Include="SearchGridForm.resx">
<DependentUpon>SearchGridForm.cs</DependentUpon>
<SubType>Designer</SubType>
</EmbeddedResource>
<EmbeddedResource Include="Properties\Resources.resx">
<Generator>ResXFileCodeGenerator</Generator>
<LastGenOutput>Resources.Designer.cs</LastGenOutput>
<SubType>Designer</SubType>
</EmbeddedResource>
<Compile Include="Properties\Resources.Designer.cs">
<AutoGen>True</AutoGen>
<DependentUpon>Resources.resx</DependentUpon>
</Compile>
<None Include="LICENSE" />
<None Include="Properties\Settings.settings">
<Generator>SettingsSingleFileGenerator</Generator>
<LastGenOutput>Settings.Designer.cs</LastGenOutput>
</None>
<Compile Include="Properties\Settings.Designer.cs">
<AutoGen>True</AutoGen>
<DependentUpon>Settings.settings</DependentUpon>
<DesignTimeSharedInput>True</DesignTimeSharedInput>
</Compile>
</ItemGroup>
<ItemGroup>
<BootstrapperPackage Include=".NETFramework,Version=v4.0,Profile=Client">
<Visible>False</Visible>
<ProductName>Microsoft .NET Framework 4 Client Profile %28x86 and x64%29</ProductName>
<Install>true</Install>
</BootstrapperPackage>
<BootstrapperPackage Include="Microsoft.Net.Client.3.5">
<Visible>False</Visible>
<ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>
<Install>false</Install>
</BootstrapperPackage>
<BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
<Visible>False</Visible>
<ProductName>.NET Framework 3.5 SP1</ProductName>
<Install>false</Install>
</BootstrapperPackage>
<BootstrapperPackage Include="Microsoft.Windows.Installer.3.1">
<Visible>False</Visible>
<ProductName>Windows Installer 3.1</ProductName>
<Install>true</Install>
</BootstrapperPackage>
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\EpPathFinding.cs\EpPathFinding.cs\EpPathFinding.cs.csproj">
<Project>{4BC2B4B0-2A38-4274-98A2-37CEF5F03B42}</Project>
<Name>EpPathFinding.cs</Name>
</ProjectReference>
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
</Project>
================================================
FILE: EpPathFindingDemo/EpPathFindingDemo.sln
================================================
Microsoft Visual Studio Solution File, Format Version 11.00
# Visual Studio 2010
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "EpPathFindingDemo", "EpPathFindingDemo.csproj", "{82FE700A-0BA3-49D0-ACE0-C1F87FBE5021}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "EpPathFinding.cs", "..\EpPathFinding.cs\EpPathFinding.cs\EpPathFinding.cs.csproj", "{4BC2B4B0-2A38-4274-98A2-37CEF5F03B42}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Debug|Mixed Platforms = Debug|Mixed Platforms
Debug|x86 = Debug|x86
Release|Any CPU = Release|Any CPU
Release|Mixed Platforms = Release|Mixed Platforms
Release|x86 = Release|x86
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{82FE700A-0BA3-49D0-ACE0-C1F87FBE5021}.Debug|Any CPU.ActiveCfg = Debug|x86
{82FE700A-0BA3-49D0-ACE0-C1F87FBE5021}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
{82FE700A-0BA3-49D0-ACE0-C1F87FBE5021}.Debug|Mixed Platforms.Build.0 = Debug|x86
{82FE700A-0BA3-49D0-ACE0-C1F87FBE5021}.Debug|x86.ActiveCfg = Debug|x86
{82FE700A-0BA3-49D0-ACE0-C1F87FBE5021}.Debug|x86.Build.0 = Debug|x86
{82FE700A-0BA3-49D0-ACE0-C1F87FBE5021}.Release|Any CPU.ActiveCfg = Release|x86
{82FE700A-0BA3-49D0-ACE0-C1F87FBE5021}.Release|Mixed Platforms.ActiveCfg = Release|x86
{82FE700A-0BA3-49D0-ACE0-C1F87FBE5021}.Release|Mixed Platforms.Build.0 = Release|x86
{82FE700A-0BA3-49D0-ACE0-C1F87FBE5021}.Release|x86.ActiveCfg = Release|x86
{82FE700A-0BA3-49D0-ACE0-C1F87FBE5021}.Release|x86.Build.0 = Release|x86
{4BC2B4B0-2A38-4274-98A2-37CEF5F03B42}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{4BC2B4B0-2A38-4274-98A2-37CEF5F03B42}.Debug|Any CPU.Build.0 = Debug|Any CPU
{4BC2B4B0-2A38-4274-98A2-37CEF5F03B42}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{4BC2B4B0-2A38-4274-98A2-37CEF5F03B42}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{4BC2B4B0-2A38-4274-98A2-37CEF5F03B42}.Debug|x86.ActiveCfg = Debug|Any CPU
{4BC2B4B0-2A38-4274-98A2-37CEF5F03B42}.Release|Any CPU.ActiveCfg = Release|Any CPU
{4BC2B4B0-2A38-4274-98A2-37CEF5F03B42}.Release|Any CPU.Build.0 = Release|Any CPU
{4BC2B4B0-2A38-4274-98A2-37CEF5F03B42}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{4BC2B4B0-2A38-4274-98A2-37CEF5F03B42}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{4BC2B4B0-2A38-4274-98A2-37CEF5F03B42}.Release|x86.ActiveCfg = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal
================================================
FILE: EpPathFindingDemo/General/SingletonHolder.cs
================================================
/*!
@file SingletonHolder.cs
@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>
<http://github.com/juhgiyo/eppathfinding.cs>
@date September 27, 2013
@brief SingletonHolder Interface
@version 2.0
@section LICENSE
The MIT License (MIT)
Copyright (c) 2013 Woong Gyu La <juhgiyo@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@section DESCRIPTION
An Interface for the SingletonHolder Class.
*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
namespace EpPathFinding.cs
{
public class SingletonHolder<T> where T : new()
{
private static T m_instance;
private SingletonHolder()
{
}
public static T Instance
{
get
{
if (m_instance == null)
{
m_instance = new T();
}
return m_instance;
}
}
}
}
================================================
FILE: EpPathFindingDemo/GridBox.cs
================================================
/*!
@file GridBox.cs
@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>
<http://github.com/juhgiyo/eppathfinding.cs>
@date July 16, 2013
@brief GridBox Interface
@version 2.0
@section LICENSE
The MIT License (MIT)
Copyright (c) 2013 Woong Gyu La <juhgiyo@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@section DESCRIPTION
An Interface for the GridBox Class.
*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Drawing;
namespace EpPathFinding.cs
{
enum BoxType { Start, End, Wall, Normal };
class GridBox:IDisposable
{
public int x, y, width, height;
public SolidBrush brush;
public Rectangle boxRec;
public BoxType boxType;
public GridBox(int iX, int iY,BoxType iType)
{
this.x = iX;
this.y = iY;
this.boxType = iType;
switch (iType)
{
case BoxType.Normal:
brush = new SolidBrush(Color.WhiteSmoke);
break;
case BoxType.End:
brush = new SolidBrush(Color.Red);
break;
case BoxType.Start:
brush = new SolidBrush(Color.Green);
break;
case BoxType.Wall:
brush = new SolidBrush(Color.Gray);
break;
}
width = 18;
height = 18;
boxRec = new Rectangle(x, y, width, height);
}
public void DrawBox(Graphics iPaper,BoxType iType)
{
if (iType == boxType)
{
boxRec.X = x;
boxRec.Y = y;
iPaper.FillRectangle(brush, boxRec);
}
}
public void SwitchBox()
{
switch (this.boxType)
{
case BoxType.Normal:
if (this.brush != null)
this.brush.Dispose();
this.brush = new SolidBrush(Color.Gray);
this.boxType = BoxType.Wall;
break;
case BoxType.Wall:
if (this.brush != null)
this.brush.Dispose();
this.brush = new SolidBrush(Color.WhiteSmoke);
this.boxType = BoxType.Normal;
break;
}
}
public void SetNormalBox()
{
if (this.brush != null)
this.brush.Dispose();
this.brush = new SolidBrush(Color.WhiteSmoke);
this.boxType = BoxType.Normal;
}
public void SetStartBox()
{
if (this.brush != null)
this.brush.Dispose();
this.brush = new SolidBrush(Color.Green);
this.boxType = BoxType.Start;
}
public void SetEndBox()
{
if (this.brush != null)
this.brush.Dispose();
this.brush = new SolidBrush(Color.Red);
this.boxType = BoxType.End;
}
public void Dispose()
{
if(this.brush!=null)
this.brush.Dispose();
}
}
}
================================================
FILE: EpPathFindingDemo/GridLine.cs
================================================
/*!
@file GridLine.cs
@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>
<http://github.com/juhgiyo/eppathfinding.cs>
@date July 16, 2013
@brief GridLine Interface
@version 2.0
@section LICENSE
The MIT License (MIT)
Copyright (c) 2013 Woong Gyu La <juhgiyo@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@section DESCRIPTION
An Interface for the GridLine Class.
*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Drawing;
namespace EpPathFinding.cs
{
class GridLine
{
public int fromX, fromY, toX, toY;
public Pen pen;
public GridLine(GridBox iFrom, GridBox iTo)
{
this.fromX = iFrom.boxRec.X + 9;
this.fromY = iFrom.boxRec.Y + 9;
this.toX = iTo.boxRec.X + 9;
this.toY = iTo.boxRec.Y + 9;
pen = new Pen(Color.Yellow);
pen.Width = 2;
}
public void drawLine(Graphics iPaper)
{
iPaper.DrawLine(pen, fromX, fromY, toX, toY);
}
public void Dispose()
{
if (this.pen != null)
this.pen.Dispose();
}
}
}
================================================
FILE: EpPathFindingDemo/LICENSE
================================================
The MIT License (MIT)
Copyright (c) 2013 Woong Gyu La <juhgiyo@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
================================================
FILE: EpPathFindingDemo/Program.cs
================================================
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace EpPathFindingDemo
{
static class Program
{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new SearchGridForm());
}
}
}
================================================
FILE: EpPathFindingDemo/Properties/AssemblyInfo.cs
================================================
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("PathTest2010")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Woong Gyu La")]
[assembly: AssemblyProduct("PathTest2010")]
[assembly: AssemblyCopyright("Copyright © Woong Gyu La 2013")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("7fd522da-b279-4de9-85fb-ab35ff160ed5")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
================================================
FILE: EpPathFindingDemo/Properties/Resources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.18047
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace PathTest2010.Properties
{
/// <summary>
/// A strongly-typed resource class, for looking up localized strings, etc.
/// </summary>
// This class was auto-generated by the StronglyTypedResourceBuilder
// class via a tool like ResGen or Visual Studio.
// To add or remove a member, edit your .ResX file then rerun ResGen
// with the /str option, or rebuild your VS project.
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
internal class Resources
{
private static global::System.Resources.ResourceManager resourceMan;
private static global::System.Globalization.CultureInfo resourceCulture;
[global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
internal Resources()
{
}
/// <summary>
/// Returns the cached ResourceManager instance used by this class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Resources.ResourceManager ResourceManager
{
get
{
if ((resourceMan == null))
{
global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("PathTest2010.Properties.Resources", typeof(Resources).Assembly);
resourceMan = temp;
}
return resourceMan;
}
}
/// <summary>
/// Overrides the current thread's CurrentUICulture property for all
/// resource lookups using this strongly typed resource class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Globalization.CultureInfo Culture
{
get
{
return resourceCulture;
}
set
{
resourceCulture = value;
}
}
}
}
================================================
FILE: EpPathFindingDemo/Properties/Resources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
</root>
================================================
FILE: EpPathFindingDemo/Properties/Settings.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.18047
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace PathTest2010.Properties
{
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "10.0.0.0")]
internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase
{
private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
public static Settings Default
{
get
{
return defaultInstance;
}
}
}
}
================================================
FILE: EpPathFindingDemo/Properties/Settings.settings
================================================
<?xml version='1.0' encoding='utf-8'?>
<SettingsFile xmlns="http://schemas.microsoft.com/VisualStudio/2004/01/settings" CurrentProfile="(Default)">
<Profiles>
<Profile Name="(Default)" />
</Profiles>
<Settings />
</SettingsFile>
================================================
FILE: EpPathFindingDemo/ResultBox.cs
================================================
/*!
@file ResultBox.cs
@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>
<http://github.com/juhgiyo/eppathfinding.cs>
@date July 16, 2013
@brief ResultBox Interface
@version 2.0
@section LICENSE
The MIT License (MIT)
Copyright (c) 2013 Woong Gyu La <juhgiyo@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@section DESCRIPTION
An Interface for the ResultBox Class.
*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Drawing;
namespace EpPathFinding.cs
{
enum ResultBoxType { Opened,Closed };
class ResultBox
{
public int x, y, width, height;
public SolidBrush brush;
public Rectangle boxRec;
public ResultBoxType boxType;
public ResultBox(int iX, int iY, ResultBoxType iType)
{
this.x = iX;
this.y = iY;
this.boxType = iType;
switch (iType)
{
case ResultBoxType.Opened:
brush = new SolidBrush(Color.AliceBlue);
break;
case ResultBoxType.Closed:
brush = new SolidBrush(Color.LightGreen);
break;
}
width = 18;
height = 18;
boxRec = new Rectangle(x, y, width, height);
}
public void drawBox(Graphics iPaper)
{
boxRec.X = x;
boxRec.Y = y;
iPaper.FillRectangle(brush, boxRec);
}
public void Dispose()
{
if(this.brush!=null)
this.brush.Dispose();
}
}
}
================================================
FILE: EpPathFindingDemo/SearchGridForm.Designer.cs
================================================
namespace EpPathFindingDemo
{
partial class SearchGridForm
{
/// <summary>
/// Required designer variable.
/// </summary>
private System.ComponentModel.IContainer components = null;
/// <summary>
/// Clean up any resources being used.
/// </summary>
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
}
#region Windows Form Designer generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
this.btnSearch = new System.Windows.Forms.Button();
this.btnClearPath = new System.Windows.Forms.Button();
this.btnClearWall = new System.Windows.Forms.Button();
this.cbUseRecursive = new System.Windows.Forms.CheckBox();
this.cbbJumpType = new System.Windows.Forms.ComboBox();
this.label1 = new System.Windows.Forms.Label();
this.SuspendLayout();
//
// btnSearch
//
this.btnSearch.Location = new System.Drawing.Point(11, 14);
this.btnSearch.Name = "btnSearch";
this.btnSearch.Size = new System.Drawing.Size(64, 25);
this.btnSearch.TabIndex = 0;
this.btnSearch.Text = "Search";
this.btnSearch.UseVisualStyleBackColor = true;
this.btnSearch.Click += new System.EventHandler(this.btnSearch_Click);
//
// btnClearPath
//
this.btnClearPath.Location = new System.Drawing.Point(81, 13);
this.btnClearPath.Name = "btnClearPath";
this.btnClearPath.Size = new System.Drawing.Size(64, 25);
this.btnClearPath.TabIndex = 1;
this.btnClearPath.Text = "Clear Path";
this.btnClearPath.UseVisualStyleBackColor = true;
this.btnClearPath.Click += new System.EventHandler(this.btnClearPath_Click);
//
// btnClearWall
//
this.btnClearWall.Location = new System.Drawing.Point(152, 12);
this.btnClearWall.Name = "btnClearWall";
this.btnClearWall.Size = new System.Drawing.Size(89, 25);
this.btnClearWall.TabIndex = 2;
this.btnClearWall.Text = "Clear Walls";
this.btnClearWall.UseVisualStyleBackColor = true;
this.btnClearWall.Click += new System.EventHandler(this.btnClearWall_Click);
//
// cbUseRecursive
//
this.cbUseRecursive.AutoSize = true;
this.cbUseRecursive.Location = new System.Drawing.Point(533, 17);
this.cbUseRecursive.Name = "cbUseRecursive";
this.cbUseRecursive.Size = new System.Drawing.Size(96, 17);
this.cbUseRecursive.TabIndex = 6;
this.cbUseRecursive.Text = "Use Recursive";
this.cbUseRecursive.UseVisualStyleBackColor = true;
//
// cbbJumpType
//
this.cbbJumpType.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
this.cbbJumpType.FormattingEnabled = true;
this.cbbJumpType.Location = new System.Drawing.Point(338, 16);
this.cbbJumpType.Name = "cbbJumpType";
this.cbbJumpType.Size = new System.Drawing.Size(189, 21);
this.cbbJumpType.TabIndex = 7;
//
// label1
//
this.label1.AutoSize = true;
this.label1.Location = new System.Drawing.Point(247, 18);
this.label1.Name = "label1";
this.label1.Size = new System.Drawing.Size(85, 13);
this.label1.TabIndex = 8;
this.label1.Text = "Diagonal Mode: ";
//
// SearchGridForm
//
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(224)))), ((int)(((byte)(224)))), ((int)(((byte)(224)))));
this.ClientSize = new System.Drawing.Size(693, 284);
this.Controls.Add(this.label1);
this.Controls.Add(this.cbbJumpType);
this.Controls.Add(this.cbUseRecursive);
this.Controls.Add(this.btnClearWall);
this.Controls.Add(this.btnClearPath);
this.Controls.Add(this.btnSearch);
this.MaximizeBox = false;
this.Name = "SearchGridForm";
this.Text = "EpPathFinding.cs Demo";
this.Paint += new System.Windows.Forms.PaintEventHandler(this.Form1_Paint);
this.MouseDown += new System.Windows.Forms.MouseEventHandler(this.Form1_MouseDown);
this.MouseMove += new System.Windows.Forms.MouseEventHandler(this.Form1_MouseMove);
this.MouseUp += new System.Windows.Forms.MouseEventHandler(this.Form1_MouseUp);
this.ResumeLayout(false);
this.PerformLayout();
}
#endregion
private System.Windows.Forms.Button btnSearch;
private System.Windows.Forms.Button btnClearPath;
private System.Windows.Forms.Button btnClearWall;
private System.Windows.Forms.CheckBox cbUseRecursive;
private System.Windows.Forms.ComboBox cbbJumpType;
private System.Windows.Forms.Label label1;
}
}
================================================
FILE: EpPathFindingDemo/SearchGridForm.cs
================================================
/*!
@file SearchGridForm.cs
@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>
<http://github.com/juhgiyo/eppathfinding>
@date July 16, 2013
@brief SearchGridForm Interface
@version 2.0
@section LICENSE
The MIT License (MIT)
Copyright (c) 2013 Woong Gyu La <juhgiyo@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@section DESCRIPTION
An Interface for the SearchGridForm Class.
*/
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using EpPathFinding.cs;
namespace EpPathFindingDemo
{
public partial class SearchGridForm : Form
{
const int width = 64;
const int height = 32;
Graphics paper;
GridBox[][] m_rectangles;
List<ResultBox> m_resultBox;
List<GridLine> m_resultLine;
GridBox m_lastBoxSelect;
BoxType m_lastBoxType;
BaseGrid searchGrid;
JumpPointParam jumpParam;
public SearchGridForm()
{
InitializeComponent();
this.DoubleBuffered = true;
m_resultBox = new List<ResultBox>();
this.Width = (width+1) * 20;
this.Height = (height+1) * 20 +100;
this.MaximumSize = new Size(this.Width, this.Height);
this.MaximizeBox = false;
m_rectangles = new GridBox[width][];
for (int widthTrav = 0; widthTrav < width; widthTrav++)
{
m_rectangles[widthTrav] = new GridBox[height];
for (int heightTrav = 0; heightTrav < height; heightTrav++)
{
if(widthTrav==(width/3) && heightTrav==(height/2))
m_rectangles[widthTrav][heightTrav] = new GridBox(widthTrav * 20, heightTrav * 20 + 50, BoxType.Start);
else if (widthTrav == 41 && heightTrav == (height / 2))
m_rectangles[widthTrav][heightTrav] = new GridBox(widthTrav * 20 , heightTrav * 20 + 50, BoxType.End);
else
m_rectangles[widthTrav][heightTrav] = new GridBox(widthTrav * 20, heightTrav * 20 + 50, BoxType.Normal);
}
}
cbbJumpType.Items.Add("Always");
cbbJumpType.Items.Add("Never");
cbbJumpType.Items.Add("IfAtLeastOneWalkable");
cbbJumpType.Items.Add("OnlyWhenNoObstacles");
cbbJumpType.SelectedIndex = 0;
m_resultLine = new List<GridLine>();
searchGrid = new StaticGrid(width, height);
// searchGrid = new DynamicGrid();
//searchGrid = new DynamicGridWPool(SingletonHolder<NodePool>.Instance);
jumpParam = new JumpPointParam(searchGrid, EndNodeUnWalkableTreatment.ALLOW,(DiagonalMovement)cbbJumpType.SelectedIndex, HeuristicMode.EUCLIDEAN);//new JumpPointParam(searchGrid, startPos, endPos, cbCrossCorners.Checked, HeuristicMode.EUCLIDEANSQR);
jumpParam.CurIterationType = cbUseRecursive.Checked ? IterationType.RECURSIVE : IterationType.LOOP;
}
private void Form1_Paint(object sender, PaintEventArgs e)
{
paper = e.Graphics;
//Draw
for (int widthTrav = 0; widthTrav < width; widthTrav++)
{
for (int heightTrav = 0; heightTrav < height; heightTrav++)
{
m_rectangles[widthTrav][heightTrav].DrawBox(paper,BoxType.Normal);
}
}
for (int resultTrav = 0; resultTrav < m_resultBox.Count; resultTrav++)
{
m_resultBox[resultTrav].drawBox(paper);
}
for (int widthTrav = 0; widthTrav < width; widthTrav++)
{
for (int heightTrav = 0; heightTrav < height; heightTrav++)
{
m_rectangles[widthTrav][heightTrav].DrawBox(paper, BoxType.Start);
m_rectangles[widthTrav][heightTrav].DrawBox(paper, BoxType.End);
m_rectangles[widthTrav][heightTrav].DrawBox(paper, BoxType.Wall);
}
}
for (int resultTrav = 0; resultTrav < m_resultLine.Count; resultTrav++)
{
m_resultLine[resultTrav].drawLine(paper);
}
}
private void Form1_MouseUp(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
m_lastBoxSelect = null;
}
}
private void Form1_MouseMove(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
if (m_lastBoxSelect == null)
{
for (int widthTrav = 0; widthTrav < width; widthTrav++)
{
for (int heightTrav = 0; heightTrav < height; heightTrav++)
{
if (m_rectangles[widthTrav][heightTrav].boxRec.IntersectsWith(new Rectangle(e.Location, new Size(1, 1))))
{
m_lastBoxType = m_rectangles[widthTrav][heightTrav].boxType;
m_lastBoxSelect = m_rectangles[widthTrav][heightTrav];
switch (m_lastBoxType)
{
case BoxType.Normal:
case BoxType.Wall:
m_rectangles[widthTrav][heightTrav].SwitchBox();
this.Invalidate();
break;
case BoxType.Start:
case BoxType.End:
break;
}
}
}
}
return;
}
else
{
for (int widthTrav = 0; widthTrav < width; widthTrav++)
{
for (int heightTrav = 0; heightTrav < height; heightTrav++)
{
if (m_rectangles[widthTrav][heightTrav].boxRec.IntersectsWith(new Rectangle(e.Location, new Size(1, 1))))
{
if (m_rectangles[widthTrav][heightTrav] == m_lastBoxSelect)
{
return;
}
else
{
switch (m_lastBoxType)
{
case BoxType.Normal:
case BoxType.Wall:
if (m_rectangles[widthTrav][heightTrav].boxType == m_lastBoxType)
{
m_rectangles[widthTrav][heightTrav].SwitchBox();
m_lastBoxSelect = m_rectangles[widthTrav][heightTrav];
this.Invalidate();
}
break;
case BoxType.Start:
m_lastBoxSelect.SetNormalBox();
m_lastBoxSelect = m_rectangles[widthTrav][heightTrav];
m_lastBoxSelect.SetStartBox();
this.Invalidate();
break;
case BoxType.End:
m_lastBoxSelect.SetNormalBox();
m_lastBoxSelect = m_rectangles[widthTrav][heightTrav];
m_lastBoxSelect.SetEndBox();
this.Invalidate();
break;
}
}
}
}
}
}
}
}
private void Form1_MouseDown(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
for (int widthTrav = 0; widthTrav < width; widthTrav++)
{
for (int heightTrav = 0; heightTrav < height; heightTrav++)
{
if (m_rectangles[widthTrav][heightTrav].boxRec.IntersectsWith(new Rectangle(e.Location, new Size(1, 1))))
{
m_lastBoxType=m_rectangles[widthTrav][heightTrav].boxType;
m_lastBoxSelect = m_rectangles[widthTrav][heightTrav];
switch(m_lastBoxType)
{
case BoxType.Normal:
case BoxType.Wall:
m_rectangles[widthTrav][heightTrav].SwitchBox();
this.Invalidate();
break;
case BoxType.Start:
case BoxType.End:
break;
}
}
}
}
}
}
private void btnSearch_Click(object sender, EventArgs e)
{
for (int resultTrav = 0; resultTrav < m_resultLine.Count; resultTrav++)
{
m_resultLine[resultTrav].Dispose();
}
m_resultLine.Clear();
for (int resultTrav = 0; resultTrav < m_resultBox.Count; resultTrav++)
{
m_resultBox[resultTrav].Dispose();
}
m_resultBox.Clear();
GridPos startPos = new GridPos();
GridPos endPos = new GridPos();
for (int widthTrav = 0; widthTrav < width; widthTrav++)
{
for (int heightTrav = 0; heightTrav < height; heightTrav++)
{
if (m_rectangles[widthTrav][heightTrav].boxType != BoxType.Wall)
{
searchGrid.SetWalkableAt(new GridPos(widthTrav, heightTrav), true);
}
else
{
searchGrid.SetWalkableAt(new GridPos(widthTrav, heightTrav), false);
}
if(m_rectangles[widthTrav][heightTrav].boxType==BoxType.Start)
{
startPos.x=widthTrav;
startPos.y=heightTrav;
}
if(m_rectangles[widthTrav][heightTrav].boxType==BoxType.End)
{
endPos.x=widthTrav;
endPos.y=heightTrav;
}
}
}
jumpParam.DiagonalMovement = (DiagonalMovement)cbbJumpType.SelectedIndex;
jumpParam.CurIterationType = cbUseRecursive.Checked ? IterationType.RECURSIVE : IterationType.LOOP;
jumpParam.Reset(startPos, endPos);
List<GridPos> resultList = JumpPointFinder.FindPath(jumpParam);
for (int resultTrav = 0; resultTrav < resultList.Count-1; resultTrav++)
{
m_resultLine.Add(new GridLine(m_rectangles[resultList[resultTrav].x][resultList[resultTrav].y],m_rectangles[resultList[resultTrav+1].x][resultList[resultTrav+1].y]));
}
for (int widthTrav = 0; widthTrav < jumpParam.SearchGrid.width; widthTrav++)
{
for (int heightTrav = 0; heightTrav < jumpParam.SearchGrid.height; heightTrav++)
{
if(jumpParam.SearchGrid.GetNodeAt(widthTrav, heightTrav)==null)
continue;
if (jumpParam.SearchGrid.GetNodeAt(widthTrav, heightTrav).isOpened)
{
ResultBox resultBox = new ResultBox(widthTrav * 20, heightTrav * 20 + 50, ResultBoxType.Opened);
m_resultBox.Add(resultBox);
}
if (jumpParam.SearchGrid.GetNodeAt(widthTrav, heightTrav).isClosed)
{
ResultBox resultBox = new ResultBox(widthTrav * 20, heightTrav * 20 + 50, ResultBoxType.Closed);
m_resultBox.Add(resultBox);
}
}
}
this.Invalidate();
}
private void btnClearPath_Click(object sender, EventArgs e)
{
for (int resultTrav = 0; resultTrav < m_resultLine.Count; resultTrav++)
{
m_resultLine[resultTrav].Dispose();
}
m_resultLine.Clear();
for (int resultTrav = 0; resultTrav < m_resultBox.Count; resultTrav++)
{
m_resultBox[resultTrav].Dispose();
}
m_resultBox.Clear();
this.Invalidate();
}
private void btnClearWall_Click(object sender, EventArgs e)
{
for (int resultTrav = 0; resultTrav < m_resultLine.Count; resultTrav++)
{
m_resultLine[resultTrav].Dispose();
}
m_resultLine.Clear();
for (int resultTrav = 0; resultTrav < m_resultBox.Count; resultTrav++)
{
m_resultBox[resultTrav].Dispose();
}
m_resultBox.Clear();
for (int widthTrav = 0; widthTrav < width; widthTrav++)
{
for (int heightTrav = 0; heightTrav < height; heightTrav++)
{
switch (m_rectangles[widthTrav][heightTrav].boxType)
{
case BoxType.Normal:
case BoxType.Start:
case BoxType.End:
break;
case BoxType.Wall:
m_rectangles[widthTrav][heightTrav].SetNormalBox();
break;
}
}
}
this.Invalidate();
}
}
}
================================================
FILE: EpPathFindingDemo/SearchGridForm.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
</root>
================================================
FILE: README.md
================================================
EpPathFinding.cs
================
#### A jump point search algorithm for grid based games in C# ####
For 3D Environment
-----------------
You may take a look at [EpPathFinding3D.cs](https://github.com/juhgiyo/EpPathFinding3D.cs)
Introduction
------------
This project was started after I was inspired by [PathFinding.js by Xueqiao Xu](https://github.com/qiao/PathFinding.js) and [the article by D. Harabor](http://harablog.wordpress.com/2011/09/07/jump-point-search/).
It comes along with a demo to show how the agorithm execute as similar to Xueqiao Xu's [Online Demo](http://qiao.github.com/PathFinding.js/visual).
Unity Integration Guide
------------
Copy `EpPathFinding.cs\PathFinder` folder intto your `Unity Project's Assets` folder. Then within the script file, you want to use the `EpPathFinding.cs`, just add `using EpPathFinding.cs;` namespace at the top of the file, and use it as the guide below.
(If you have a problem when compiling, please refer to [Unity Forum](http://forum.unity3d.com/threads/monodevelop-problems-with-default-parameters.67867/#post-898994))
Also `EpPathFinding.cs` depends on [C5](https://github.com/sestoft/C5).
Pre-compiled C5.dll for Unity is included in `EpPathFinding3D.cs\PathFinder\UnityC5` folder.
(Please refer to [C5 on Unity3D](https://github.com/sestoft/C5#c5-on-unity3d), if you have any dependency issue with C5.)
Nuget Package
------------
[Nuget Package](https://www.nuget.org/packages/EpPathFinding.cs/)
Basic Usage
------------
The usage and the demo has been made very similar to [PathFinding.js](https://github.com/qiao/PathFinding.js) for ease of usage.
You first need to build a grid-map. (For example: width 64 and height 32):
```c#
BaseGrid searchGrid = new StaticGrid(64, 32);
```
By default, every nodes in the grid will NOT allow to be walked through. To set whether a node at a given coordinate is walkable or not, use the `SetWalkableAt` function.
For example, in order to set the node at (10 , 20) to be walkable, where 10 is the x coordinate (from left to right), and 20 is the y coordinate (from top to bottom):
```c#
searchGrid.SetWalkableAt(10, 20, true);
// OR
searchGrid.SetWalkableAt(new GridPos(10,20),true);
```
You may also use in a 2-d array while instantiating the `StaticGrid` class. It will initiate all the nodes in the grid with the walkability indicated by the array. (`true` for walkable otherwise not walkable):
```c#
bool [][] movableMatrix = new bool [width][];
for(int widthTrav=0; widthTrav< 64; widthTrav++)
{
movableMatrix[widthTrav]=new bool[height];
for(int heightTrav=0; heightTrav < 32; heightTrav++)
{
movableMatrix[widthTrav][heightTrav]=true;
}
}
Grid searchGrid = new StaticGrid(64,32, movableMatrix);
```
In order to search the route from (10,10) to (20,10), you need to create `JumpPointParam` class with grid and start/end positions. (Note: both the start point and end point must be walkable):
```c#
GridPos startPos=new GridPos(10,10);
GridPos endPos = new GridPos(20,10);
JumpPointParam jpParam = new JumpPointParam(searchGrid,startPos,endPos );
```
You can also set/change the start and end positions later. (However the start and end positions must be set before the actual search):
```c#
JumpPoinParam jpParam = new JumpPointParam(searchGrid);
jpParam.Reset(new GridPos(10,10), new GridPos(20,10));
```
To find a path, simply run `FindPath` function with `JumpPointParam` object created above:
```c#
List<GridPos> resultPathList = JumpPointFinder.FindPath(jpParam);
```
`JumpPointParam` class can be used as much as you want with different start/end positions unlike [PathFinding.js](https://github.com/qiao/PathFinding.js):
```c#
jpParam.Reset(new GridPos(15,15), new GridPos(20,15));
resultPathList = JumpPointFinder.FindPath(jpParam);
```
Advanced Usage
------------
#### Find the path even the end node is unwalkable ####
When instantiating the `JumpPointParam`, you may pass in additional parameter to make the search able to find path even the end node is unwalkable grid:
```
Note that it automatically sets to ALLOW as a default when the parameter is not specified.
```
```c#
JumpPointParam jpParam = new JumpPointParam(searchGrid,EndNodeUnWalkableTreatment.ALLOW);
```
If `iAllowEndNodeUnWalkable` is DISALLOW the FindPath will return the empty path if the end node is unwalkable:
```c#
JumpPointParam jpParam = new JumpPointParam(searchGrid,EndNodeUnWalkableTreatment.DISALLOW);
```
#### DiagonalMovement.Always (Cross Adjacent Point) ####
In order to make search able to walk diagonally across corner of two diagonal unwalkable nodes:
```c#
JumpPointParam jpParam = new JumpPointParam(searchGrid,EndNodeUnWalkableTreatment.ALLOW,DiagonalMovement.Always);
```
#### DiagonalMovement.IfAtLeastOneWalkable (Cross Corner) ####
When instantiating the `JumpPointParam`, to make the search able to walk diagonally when one of the side is unwalkable grid:
```c#
JumpPointParam jpParam = new JumpPointParam(searchGrid,EndNodeUnWalkableTreatment.ALLOW,DiagonalMovement.IfAtLeastOneWalkable);
```
#### DiagonalMovement.OnlyWhenNoObstacles ####
To make it unable to walk diagonally when one of the side is unwalkable and rather go around the corner:
```c#
JumpPointParam jpParam = new JumpPointParam(searchGrid,EndNodeUnWalkableTreatment.ALLOW,DiagonalMovement.OnlyWhenNoObstacles);
```
#### DiagonalMovement.Never ####
To make it unable to walk diagonally:
```c#
// Special thanks to Nil Amar for the idea!
JumpPointParam jpParam = new JumpPointParam(searchGrid,EndNodeUnWalkableTreatment.ALLOW,DiagonalMovement.Never);
```
#### Heuristic Functions ####
The predefined heuristics are `Heuristic.EUCLIDEAN` (default), `Heuristic.MANHATTAN`, and `Heuristic.CHEBYSHEV`.
To use the `MANHATTAN` heuristic:
```c#
JumpPointParam jpParam = new JumpPointParam(searchGrid,EndNodeUnWalkableTreatment.ALLOW, DiagonalMovement.Always, Heuristic.MANHATTAN);
```
You can always change the heuristics later with `SetHeuristic` function:
```c#
jpParam.SetHeuristic(Heuristic.MANHATTAN);
```
#### Dynamic Grid ####
For my grid-based game, I had much less walkable grid nodes than un-walkable grid nodes. So above `StaticGrid` was wasting too much memory to hold un-walkable grid nodes. To avoid the memory waste, I have created `DynamicGrid`, which allocates the memory for only walkable grid nodes.
(Please note that there is trade off of memory and performance. This degrades the performance to improve memory usage.)
```c#
BaseGrid seachGrid = new DynamicGrid();
```
You may also use a `List` of walkable `GridPos`, while instantiating the `DynamicGrid` class. It will initiate only the nodes in the grid where the walkability is `true`:
```c#
List<GridPos> walkableGridPosList= new List<GridPos>();
for(int widthTrav=0; widthTrav< 64; widthTrav++)
{
movableMatrix[widthTrav]=new bool[height];
for(int heightTrav=0; heightTrav < 32; heightTrav++)
{
walkableGridPosList.Add(new GridPos(widthTrav, heightTrav));
}
}
BaseGrid searchGrid = new DynamicGrid(walkableGridPosList);
```
Rest of the functionality like `SetWalkableAt`, `Reset`, etc. are same as `StaticGrid`.
#### Dynamic Grid With Pool ####
In many cases, you might want to reuse the same grid for next search. And this can be extremely useful when used with `PartialGridWPool`, since you don't have to allocate the grid again.
```c#
NodePool nodePool = new NodePool();
BaseGrid seachGrid = new DynamicGridWPool(nodePool);
```
Rest of the functionality like `SetWalkableAt`, `Reset`, etc. are same as `DynamicGrid`.
#### Partial Grid With Pool ####
As mentioned above, if you want to search only partial of the grid for performance reason, you can use `PartialGridWPool`. Just give the `GridRect` which shows the portion of the grid you want to search within.
```c#
NodePool nodePool = new NodePool();
...
BaseGrid seachGrid = new PartialGridWPool(nodePool, new GridRect(1,3,15,30);
```
Rest of the functionality like `SetWalkableAt`, `Reset`, etc. are same as `DynamicGridWPool`.
#### IterationType ####
You may use recursive function or loop function to find the path. This can be simply done by setting IterationType flag in JumpPointParam:
```
Note that the default is IterationType.LOOP, which uses loop function.
```
```c#
// To use recursive function
JumpPointParam jpParam = new JumpPointParam(...);
jpParam.IterationType = IterationType.RECURSIVE;
```
To change back to loop function
```c#
// To change back to loop function
jpParam.IterationType = IterationType.LOOP;
```
#### Extendability ####
You can also create a sub-class of `BaseGrid` to create your own way of `Grid` class to best support your situation.
License
-------
[The MIT License](http://opensource.org/licenses/mit-license.php)
Copyright (c) 2013 Woong Gyu La <[juhgiyo@gmail.com](mailto:juhgiyo@gmail.com)>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
================================================
FILE: _config.yml
================================================
theme: jekyll-theme-cayman
gitextract_a16lqtoo/ ├── .gitignore ├── EpPathFinding.cs/ │ ├── EpPathFinding.cs/ │ │ ├── EpPathFinding.cs.csproj │ │ ├── PathFinder/ │ │ │ ├── AStarFinder.cs │ │ │ ├── DiagonalMovement.cs │ │ │ ├── Grid/ │ │ │ │ ├── BaseGrid.cs │ │ │ │ ├── DynamicGrid.cs │ │ │ │ ├── DynamicGridWPool.cs │ │ │ │ ├── PartialGridWPool.cs │ │ │ │ └── StaticGrid.cs │ │ │ ├── GridPos.cs │ │ │ ├── GridRect.cs │ │ │ ├── Heuristic.cs │ │ │ ├── JumpPointFinder.cs │ │ │ ├── NodePool.cs │ │ │ ├── ParamBase.cs │ │ │ └── Util.cs │ │ ├── Properties/ │ │ │ └── AssemblyInfo.cs │ │ └── packages.config │ ├── EpPathFinding.cs.nupkg │ └── EpPathFinding.cs.sln ├── EpPathFindingDemo/ │ ├── EpPathFindingDemo.csproj │ ├── EpPathFindingDemo.sln │ ├── General/ │ │ └── SingletonHolder.cs │ ├── GridBox.cs │ ├── GridLine.cs │ ├── LICENSE │ ├── Program.cs │ ├── Properties/ │ │ ├── AssemblyInfo.cs │ │ ├── Resources.Designer.cs │ │ ├── Resources.resx │ │ ├── Settings.Designer.cs │ │ └── Settings.settings │ ├── ResultBox.cs │ ├── SearchGridForm.Designer.cs │ ├── SearchGridForm.cs │ └── SearchGridForm.resx ├── README.md └── _config.yml
SYMBOL INDEX (179 symbols across 23 files)
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/AStarFinder.cs
class AStarParam (line 17) | public class AStarParam : ParamBase
method AStarParam (line 24) | public AStarParam(BaseGrid iGrid, GridPos iStartPos, GridPos iEndPos, ...
method AStarParam (line 30) | public AStarParam(BaseGrid iGrid, float iweight, DiagonalMovement iDia...
method _reset (line 36) | internal override void _reset(GridPos iStartPos, GridPos iEndPos, Base...
class AStarFinder (line 41) | public static class AStarFinder
method FindPath (line 59) | public static List<GridPos> FindPath(AStarParam iParam)
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/DiagonalMovement.cs
type DiagonalMovement (line 9) | public enum DiagonalMovement
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/Grid/BaseGrid.cs
class Node (line 44) | public class Node : IComparable<Node>
method Node (line 56) | public Node(int iX, int iY, bool? iWalkable = null)
method Node (line 72) | public Node(Node b)
method Reset (line 85) | public void Reset(bool? iWalkable = null)
method CompareTo (line 99) | public int CompareTo(Node iObj)
method Backtrace (line 110) | public static List<GridPos> Backtrace(Node iNode)
method GetHashCode (line 124) | public override int GetHashCode()
method Equals (line 129) | public override bool Equals(System.Object obj)
method Equals (line 148) | public bool Equals(Node p)
class BaseGrid (line 185) | public abstract class BaseGrid
method BaseGrid (line 188) | public BaseGrid()
method BaseGrid (line 193) | public BaseGrid(BaseGrid b)
method GetNodeAt (line 210) | public abstract Node GetNodeAt(int iX, int iY);
method IsWalkableAt (line 212) | public abstract bool IsWalkableAt(int iX, int iY);
method SetWalkableAt (line 214) | public abstract bool SetWalkableAt(int iX, int iY, bool iWalkable);
method GetNodeAt (line 216) | public abstract Node GetNodeAt(GridPos iPos);
method IsWalkableAt (line 218) | public abstract bool IsWalkableAt(GridPos iPos);
method SetWalkableAt (line 220) | public abstract bool SetWalkableAt(GridPos iPos, bool iWalkable);
method GetNeighbors (line 222) | public List<Node> GetNeighbors(Node iNode, DiagonalMovement diagonalMo...
method Reset (line 300) | public abstract void Reset();
method Clone (line 302) | public abstract BaseGrid Clone();
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/Grid/DynamicGrid.cs
class DynamicGrid (line 45) | public class DynamicGrid : BaseGrid
method DynamicGrid (line 79) | public DynamicGrid(List<GridPos> iWalkableGridList = null)
method DynamicGrid (line 91) | public DynamicGrid(DynamicGrid b)
method buildNodes (line 98) | protected void buildNodes(List<GridPos> iWalkableGridList)
method GetNodeAt (line 111) | public override Node GetNodeAt(int iX, int iY)
method IsWalkableAt (line 117) | public override bool IsWalkableAt(int iX, int iY)
method setBoundingBox (line 123) | private void setBoundingBox()
method SetWalkableAt (line 141) | public override bool SetWalkableAt(int iX, int iY, bool iWalkable)
method GetNodeAt (line 178) | public override Node GetNodeAt(GridPos iPos)
method IsWalkableAt (line 187) | public override bool IsWalkableAt(GridPos iPos)
method SetWalkableAt (line 192) | public override bool SetWalkableAt(GridPos iPos, bool iWalkable)
method Reset (line 197) | public override void Reset()
method Reset (line 202) | public void Reset(List<GridPos> iWalkableGridList)
method Clone (line 221) | public override BaseGrid Clone()
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/Grid/DynamicGridWPool.cs
class DynamicGridWPool (line 45) | public class DynamicGridWPool : BaseGrid
method DynamicGridWPool (line 78) | public DynamicGridWPool(NodePool iNodePool)
method DynamicGridWPool (line 90) | public DynamicGridWPool(DynamicGridWPool b)
method GetNodeAt (line 97) | public override Node GetNodeAt(int iX, int iY)
method IsWalkableAt (line 103) | public override bool IsWalkableAt(int iX, int iY)
method setBoundingBox (line 109) | private void setBoundingBox()
method SetWalkableAt (line 127) | public override bool SetWalkableAt(int iX, int iY, bool iWalkable)
method GetNodeAt (line 152) | public override Node GetNodeAt(GridPos iPos)
method IsWalkableAt (line 157) | public override bool IsWalkableAt(GridPos iPos)
method SetWalkableAt (line 162) | public override bool SetWalkableAt(GridPos iPos, bool iWalkable)
method Reset (line 168) | public override void Reset()
method Clone (line 176) | public override BaseGrid Clone()
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/Grid/PartialGridWPool.cs
class PartialGridWPool (line 44) | public class PartialGridWPool : BaseGrid
method PartialGridWPool (line 73) | public PartialGridWPool(NodePool iNodePool, GridRect iGridRect = null)
method PartialGridWPool (line 83) | public PartialGridWPool(PartialGridWPool b)
method SetGridRect (line 89) | public void SetGridRect(GridRect iGridRect)
method IsInside (line 95) | public bool IsInside(int iX, int iY)
method GetNodeAt (line 102) | public override Node GetNodeAt(int iX, int iY)
method IsWalkableAt (line 108) | public override bool IsWalkableAt(int iX, int iY)
method SetWalkableAt (line 114) | public override bool SetWalkableAt(int iX, int iY, bool iWalkable)
method IsInside (line 123) | public bool IsInside(GridPos iPos)
method GetNodeAt (line 128) | public override Node GetNodeAt(GridPos iPos)
method IsWalkableAt (line 135) | public override bool IsWalkableAt(GridPos iPos)
method SetWalkableAt (line 142) | public override bool SetWalkableAt(GridPos iPos, bool iWalkable)
method Reset (line 147) | public override void Reset()
method Clone (line 175) | public override BaseGrid Clone()
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/Grid/StaticGrid.cs
class StaticGrid (line 44) | public class StaticGrid : BaseGrid
method StaticGrid (line 52) | public StaticGrid(int iWidth, int iHeight, bool[][] iMatrix = null):ba...
method StaticGrid (line 63) | public StaticGrid(StaticGrid b)
method buildNodes (line 81) | private Node[][] buildNodes(int iWidth, int iHeight, bool[][] iMatrix)
method GetNodeAt (line 122) | public override Node GetNodeAt(int iX, int iY)
method IsWalkableAt (line 127) | public override bool IsWalkableAt(int iX, int iY)
method isInside (line 132) | protected bool isInside(int iX, int iY)
method SetWalkableAt (line 137) | public override bool SetWalkableAt(int iX, int iY, bool iWalkable)
method isInside (line 143) | protected bool isInside(GridPos iPos)
method GetNodeAt (line 148) | public override Node GetNodeAt(GridPos iPos)
method IsWalkableAt (line 153) | public override bool IsWalkableAt(GridPos iPos)
method SetWalkableAt (line 158) | public override bool SetWalkableAt(GridPos iPos, bool iWalkable)
method Reset (line 163) | public override void Reset()
method Reset (line 168) | public void Reset(bool[][] iMatrix)
method Clone (line 203) | public override BaseGrid Clone()
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/GridPos.cs
class GridPos (line 44) | public class GridPos : IEquatable<GridPos>
method GridPos (line 49) | public GridPos()
method GridPos (line 54) | public GridPos(int iX, int iY)
method GridPos (line 60) | public GridPos(GridPos b)
method GetHashCode (line 66) | public override int GetHashCode()
method Equals (line 71) | public override bool Equals(System.Object obj)
method Equals (line 87) | public bool Equals(GridPos p)
method Set (line 121) | public GridPos Set(int iX, int iY)
method ToString (line 128) | public override string ToString()
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/GridRect.cs
class GridRect (line 44) | public class GridRect
method GridRect (line 50) | public GridRect()
method GridRect (line 57) | public GridRect(int iMinX, int iMinY, int iMaxX, int iMaxY)
method GridRect (line 65) | public GridRect(GridRect b)
method GetHashCode (line 73) | public override int GetHashCode()
method Equals (line 78) | public override bool Equals(System.Object obj)
method Equals (line 92) | public bool Equals(GridRect p)
method Set (line 126) | public GridRect Set(int iMinX, int iMinY, int iMaxX, int iMaxY)
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/Heuristic.cs
type HeuristicMode (line 44) | public enum HeuristicMode
class Heuristic (line 52) | public class Heuristic
method Manhattan (line 54) | public static float Manhattan(int iDx, int iDy)
method Euclidean (line 59) | public static float Euclidean(int iDx, int iDy)
method Chebyshev (line 66) | public static float Chebyshev(int iDx, int iDy)
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/JumpPointFinder.cs
type IterationType (line 46) | public enum IterationType
type EndNodeUnWalkableTreatment (line 52) | public enum EndNodeUnWalkableTreatment
class JumpPointParam (line 59) | public class JumpPointParam : ParamBase
method JumpPointParam (line 61) | [System.Obsolete("This constructor is deprecated, please use the Const...
method JumpPointParam (line 71) | [System.Obsolete("This constructor is deprecated, please use the Const...
method JumpPointParam (line 81) | [System.Obsolete("This constructor is deprecated, please use the Const...
method JumpPointParam (line 92) | [System.Obsolete("This constructor is deprecated, please use the Const...
method JumpPointParam (line 103) | public JumpPointParam(BaseGrid iGrid, GridPos iStartPos, GridPos iEndP...
method JumpPointParam (line 113) | public JumpPointParam(BaseGrid iGrid, EndNodeUnWalkableTreatment iAllo...
method JumpPointParam (line 123) | public JumpPointParam(JumpPointParam b):base(b)
method _reset (line 135) | internal override void _reset(GridPos iStartPos, GridPos iEndPos, Base...
class JumpPointFinder (line 182) | public class JumpPointFinder
method GetFullPath (line 184) | public static List<GridPos> GetFullPath(List<GridPos> routeFound)
method FindPath (line 219) | public static List<GridPos> FindPath(JumpPointParam iParam)
method identifySuccessors (line 270) | private static void identifySuccessors(JumpPointParam iParam, Node iNode)
class JumpSnapshot (line 321) | private class JumpSnapshot
method JumpSnapshot (line 330) | public JumpSnapshot()
method jumpLoop (line 343) | private static GridPos jumpLoop(JumpPointParam iParam, int iX, int iY,...
method jump (line 729) | private static GridPos jump(JumpPointParam iParam, int iX, int iY, int...
method findNeighbors (line 897) | private static List<GridPos> findNeighbors(JumpPointParam iParam, Node...
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/NodePool.cs
class NodePool (line 44) | public class NodePool
method NodePool (line 48) | public NodePool()
method GetNode (line 57) | public Node GetNode(int iX, int iY)
method GetNode (line 63) | public Node GetNode(GridPos iPos)
method SetNode (line 70) | public Node SetNode(int iX, int iY, bool? iWalkable = null)
method SetNode (line 76) | public Node SetNode(GridPos iPos, bool? iWalkable = null)
method removeNode (line 105) | protected void removeNode(int iX, int iY)
method removeNode (line 110) | protected void removeNode(GridPos iPos)
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/ParamBase.cs
class ParamBase (line 10) | public abstract class ParamBase
method ParamBase (line 12) | public ParamBase(BaseGrid iGrid, GridPos iStartPos, GridPos iEndPos, D...
method ParamBase (line 22) | public ParamBase(BaseGrid iGrid, DiagonalMovement iDiagonalMovement, H...
method ParamBase (line 32) | public ParamBase(ParamBase param)
method _reset (line 41) | internal abstract void _reset(GridPos iStartPos, GridPos iEndPos, Base...
method Reset (line 43) | public void Reset(GridPos iStartPos, GridPos iEndPos, BaseGrid iSearch...
method SetHeuristic (line 92) | public void SetHeuristic(HeuristicMode iMode)
FILE: EpPathFinding.cs/EpPathFinding.cs/PathFinder/Util.cs
class Util (line 8) | public class Util
method GetDiagonalMovement (line 10) | public static DiagonalMovement GetDiagonalMovement(bool iCrossCorners,...
FILE: EpPathFindingDemo/General/SingletonHolder.cs
class SingletonHolder (line 46) | public class SingletonHolder<T> where T : new()
method SingletonHolder (line 50) | private SingletonHolder()
FILE: EpPathFindingDemo/GridBox.cs
type BoxType (line 47) | enum BoxType { Start, End, Wall, Normal };
class GridBox (line 49) | class GridBox:IDisposable
method GridBox (line 55) | public GridBox(int iX, int iY,BoxType iType)
method DrawBox (line 81) | public void DrawBox(Graphics iPaper,BoxType iType)
method SwitchBox (line 92) | public void SwitchBox()
method SetNormalBox (line 112) | public void SetNormalBox()
method SetStartBox (line 120) | public void SetStartBox()
method SetEndBox (line 128) | public void SetEndBox()
method Dispose (line 137) | public void Dispose()
FILE: EpPathFindingDemo/GridLine.cs
class GridLine (line 47) | class GridLine
method GridLine (line 52) | public GridLine(GridBox iFrom, GridBox iTo)
method drawLine (line 64) | public void drawLine(Graphics iPaper)
method Dispose (line 71) | public void Dispose()
FILE: EpPathFindingDemo/Program.cs
class Program (line 9) | static class Program
method Main (line 14) | [STAThread]
FILE: EpPathFindingDemo/Properties/Resources.Designer.cs
class Resources (line 22) | [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resource...
method Resources (line 32) | [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Mic...
FILE: EpPathFindingDemo/Properties/Settings.Designer.cs
class Settings (line 15) | [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
FILE: EpPathFindingDemo/ResultBox.cs
type ResultBoxType (line 47) | enum ResultBoxType { Opened,Closed };
class ResultBox (line 48) | class ResultBox
method ResultBox (line 54) | public ResultBox(int iX, int iY, ResultBoxType iType)
method drawBox (line 75) | public void drawBox(Graphics iPaper)
method Dispose (line 84) | public void Dispose()
FILE: EpPathFindingDemo/SearchGridForm.Designer.cs
class SearchGridForm (line 3) | partial class SearchGridForm
method Dispose (line 14) | protected override void Dispose(bool disposing)
method InitializeComponent (line 29) | private void InitializeComponent()
FILE: EpPathFindingDemo/SearchGridForm.cs
class SearchGridForm (line 51) | public partial class SearchGridForm : Form
method SearchGridForm (line 66) | public SearchGridForm()
method Form1_Paint (line 115) | private void Form1_Paint(object sender, PaintEventArgs e)
method Form1_MouseUp (line 155) | private void Form1_MouseUp(object sender, MouseEventArgs e)
method Form1_MouseMove (line 163) | private void Form1_MouseMove(object sender, MouseEventArgs e)
method Form1_MouseDown (line 250) | private void Form1_MouseDown(object sender, MouseEventArgs e)
method btnSearch_Click (line 283) | private void btnSearch_Click(object sender, EventArgs e)
method btnClearPath_Click (line 355) | private void btnClearPath_Click(object sender, EventArgs e)
method btnClearWall_Click (line 373) | private void btnClearWall_Click(object sender, EventArgs e)
Condensed preview — 38 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (196K chars).
[
{
"path": ".gitignore",
"chars": 37,
"preview": "*.pdb\nDebug/\nRelease/\n*.suo\npackages/"
},
{
"path": "EpPathFinding.cs/EpPathFinding.cs/EpPathFinding.cs.csproj",
"chars": 3296,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<Project ToolsVersion=\"4.0\" DefaultTargets=\"Build\" xmlns=\"http://schemas.microso"
},
{
"path": "EpPathFinding.cs/EpPathFinding.cs/PathFinder/AStarFinder.cs",
"chars": 4578,
"preview": "#if (UNITY_EDITOR || UNITY_EDITOR_WIN || UNITY_EDITOR_OSX || UNITY_STANDALONE_OSX || UNITY_STANDALONE_WIN || UNITY_STAN"
},
{
"path": "EpPathFinding.cs/EpPathFinding.cs/PathFinder/DiagonalMovement.cs",
"chars": 254,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace EpPathFinding.cs\n\n{\n "
},
{
"path": "EpPathFinding.cs/EpPathFinding.cs/PathFinder/Grid/BaseGrid.cs",
"chars": 9192,
"preview": "/*! \n@file BaseGrid.cs\n@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>\n\t\t<http://github.com/juhgiyo/eppathfinding"
},
{
"path": "EpPathFinding.cs/EpPathFinding.cs/PathFinder/Grid/DynamicGrid.cs",
"chars": 6913,
"preview": "/*! \n@file DynamicGrid.cs\n@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>\n\t\t<http://github.com/juhgiyo/eppathfind"
},
{
"path": "EpPathFinding.cs/EpPathFinding.cs/PathFinder/Grid/DynamicGridWPool.cs",
"chars": 5415,
"preview": "/*! \n@file DynamicGridWPool.cs\n@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>\n\t\t<http://github.com/juhgiyo/eppat"
},
{
"path": "EpPathFinding.cs/EpPathFinding.cs/PathFinder/Grid/PartialGridWPool.cs",
"chars": 5214,
"preview": "/*! \n@file PartialGridWPool.cs\n@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>\n\t\t<http://github.com/juhgiyo/eppath"
},
{
"path": "EpPathFinding.cs/EpPathFinding.cs/PathFinder/Grid/StaticGrid.cs",
"chars": 7138,
"preview": "/*! \n@file StaticGrid.cs\n@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>\n\t\t<http://github.com/juhgiyo/eppathfindi"
},
{
"path": "EpPathFinding.cs/EpPathFinding.cs/PathFinder/GridPos.cs",
"chars": 3616,
"preview": "/*! \n@file GridPos.cs\n@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>\n\t\t<http://github.com/juhgiyo/eppathfinding."
},
{
"path": "EpPathFinding.cs/EpPathFinding.cs/PathFinder/GridRect.cs",
"chars": 4016,
"preview": "/*! \n@file GridRect.cs\n@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>\n\t\t<http://github.com/juhgiyo/eppathfinding."
},
{
"path": "EpPathFinding.cs/EpPathFinding.cs/PathFinder/Heuristic.cs",
"chars": 2095,
"preview": "/*! \n@file Heuristic.cs\n@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>\n\t\t<http://github.com/juhgiyo/eppathfindin"
},
{
"path": "EpPathFinding.cs/EpPathFinding.cs/PathFinder/JumpPointFinder.cs",
"chars": 55765,
"preview": "/*! \n@file JumpPointFinder.cs\n@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>\n\t\t<http://github.com/juhgiyo/eppath"
},
{
"path": "EpPathFinding.cs/EpPathFinding.cs/PathFinder/NodePool.cs",
"chars": 3438,
"preview": "/*! \n@file NodePool.cs\n@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>\n\t\t<http://github.com/juhgiyo/eppathfinding."
},
{
"path": "EpPathFinding.cs/EpPathFinding.cs/PathFinder/ParamBase.cs",
"chars": 3646,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace EpPathFinding.cs\n{\n "
},
{
"path": "EpPathFinding.cs/EpPathFinding.cs/PathFinder/Util.cs",
"chars": 641,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace EpPathFinding.cs\n{\n "
},
{
"path": "EpPathFinding.cs/EpPathFinding.cs/Properties/AssemblyInfo.cs",
"chars": 1405,
"preview": "using System.Reflection;\nusing System.Runtime.CompilerServices;\nusing System.Runtime.InteropServices;\n\n// General Infor"
},
{
"path": "EpPathFinding.cs/EpPathFinding.cs/packages.config",
"chars": 133,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<packages>\n <package id=\"C5\" version=\"2.4.5947.17249\" targetFramework=\"net40\" /"
},
{
"path": "EpPathFinding.cs/EpPathFinding.cs.sln",
"chars": 916,
"preview": "\nMicrosoft Visual Studio Solution File, Format Version 11.00\n# Visual Studio 2010\nProject(\"{FAE04EC0-301F-11D3-BF4B-00C"
},
{
"path": "EpPathFindingDemo/EpPathFindingDemo.csproj",
"chars": 5726,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<Project ToolsVersion=\"4.0\" DefaultTargets=\"Build\" xmlns=\"http://schemas.microso"
},
{
"path": "EpPathFindingDemo/EpPathFindingDemo.sln",
"chars": 2557,
"preview": "\nMicrosoft Visual Studio Solution File, Format Version 11.00\n# Visual Studio 2010\nProject(\"{FAE04EC0-301F-11D3-BF4B-00C"
},
{
"path": "EpPathFindingDemo/General/SingletonHolder.cs",
"chars": 1941,
"preview": "/*! \n@file SingletonHolder.cs\n@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>\n\t\t<http://github.com/juhgiyo/eppathf"
},
{
"path": "EpPathFindingDemo/GridBox.cs",
"chars": 4284,
"preview": "/*! \n@file GridBox.cs\n@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>\n\t\t<http://github.com/juhgiyo/eppathfinding."
},
{
"path": "EpPathFindingDemo/GridLine.cs",
"chars": 2242,
"preview": "/*! \n@file GridLine.cs\n@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>\n\t\t<http://github.com/juhgiyo/eppathfinding"
},
{
"path": "EpPathFindingDemo/LICENSE",
"chars": 1099,
"preview": "\nThe MIT License (MIT)\n\nCopyright (c) 2013 Woong Gyu La <juhgiyo@gmail.com>\n\nPermission is hereby granted, free of charg"
},
{
"path": "EpPathFindingDemo/Program.cs",
"chars": 525,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Threading.Tasks;\nusing System.Windows.F"
},
{
"path": "EpPathFindingDemo/Properties/AssemblyInfo.cs",
"chars": 1421,
"preview": "using System.Reflection;\nusing System.Runtime.CompilerServices;\nusing System.Runtime.InteropServices;\n\n// General Infor"
},
{
"path": "EpPathFindingDemo/Properties/Resources.Designer.cs",
"chars": 2781,
"preview": "//------------------------------------------------------------------------------\n// <auto-generated>\n// This code w"
},
{
"path": "EpPathFindingDemo/Properties/Resources.resx",
"chars": 5494,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<root>\n <!-- \n Microsoft ResX Schema \n \n Version 2.0\n \n The prim"
},
{
"path": "EpPathFindingDemo/Properties/Settings.Designer.cs",
"chars": 1067,
"preview": "//------------------------------------------------------------------------------\n// <auto-generated>\n// This code w"
},
{
"path": "EpPathFindingDemo/Properties/Settings.settings",
"chars": 240,
"preview": "<?xml version='1.0' encoding='utf-8'?>\n<SettingsFile xmlns=\"http://schemas.microsoft.com/VisualStudio/2004/01/settings\""
},
{
"path": "EpPathFindingDemo/ResultBox.cs",
"chars": 2676,
"preview": "/*! \n@file ResultBox.cs\n@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>\n\t\t<http://github.com/juhgiyo/eppathfindin"
},
{
"path": "EpPathFindingDemo/SearchGridForm.Designer.cs",
"chars": 5790,
"preview": "namespace EpPathFindingDemo\n{\n partial class SearchGridForm\n {\n /// <summary>\n /// Required designe"
},
{
"path": "EpPathFindingDemo/SearchGridForm.cs",
"chars": 15999,
"preview": "/*! \n@file SearchGridForm.cs\n@author Woong Gyu La a.k.a Chris. <juhgiyo@gmail.com>\n\t\t<http://github.com/juhgiyo/eppathf"
},
{
"path": "EpPathFindingDemo/SearchGridForm.resx",
"chars": 5696,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<root>\n <!-- \n Microsoft ResX Schema \n \n Version 2.0\n \n The prim"
},
{
"path": "README.md",
"chars": 9986,
"preview": "EpPathFinding.cs\n================\n#### A jump point search algorithm for grid based games in C# ####\n\nFor 3D Environment"
},
{
"path": "_config.yml",
"chars": 26,
"preview": "theme: jekyll-theme-cayman"
}
]
// ... and 1 more files (download for full content)
About this extraction
This page contains the full source code of the juhgiyo/EpPathFinding.cs GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 38 files (182.9 KB), approximately 42.5k tokens, and a symbol index with 179 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.