/// <summary>
/// Initializes the pipeline.
/// </summary>
private void CreatePipeline()
{
// Create empty pipeline.
_pipelineMultiThreaded = new Pipeline <FindPathInput, NavTilePath>();
// Create Pathfinding instance.
if (string.IsNullOrEmpty(AlgorithmType))
{
throw new Exception("Did not set the algorithm");
}
Type algorithm = Type.GetType(AlgorithmType);
_algorithm = Activator.CreateInstance(algorithm) as IPathfindingAlgorithm;
_pipelineMultiThreaded.AddStep <FindPathInput, NavTilePath>(_algorithm.FindPath, NumberOfThreads);
List <Type> smoothing = new List <Type>();
foreach (var smoothingAlgorithm in EnabledSmoothingAlgorithms)
{
smoothing.Add(Type.GetType(smoothingAlgorithm));
}
foreach (var type in smoothing)
{
var instance = Activator.CreateInstance(type) as INavTilePathModifier;
_pipelineMultiThreaded.AddStep <NavTilePath, NavTilePath>(instance.ModifyPath, 1);
}
}
/// <summary>
/// Bakes all tiles into the NavTile dictionary for the current scene.
/// </summary>
public void Bake(IPathfindingAlgorithm inAlgorithm)
{
GridInfo.InitializeGridInfo(Grid);
InitDataForCurrentScene();
if (GetAllTilemaps())
{
GenerateNavTileData();
Data.CurrentBakeState = NavTileSurfaceData.BakeState.Standard;
if (inAlgorithm is JPSPlus)
{
(inAlgorithm as JPSPlus).GenerateAdditionalTileData(Data);
Data.CurrentBakeState = NavTileSurfaceData.BakeState.AdditionalData;
}
#if UNITY_EDITOR
EditorUtility.DisplayProgressBar("Saving Baked NavData", $"Saving NavData", 0.5f);
#endif
Data.Save();
#if UNITY_EDITOR
EditorUtility.ClearProgressBar();
#endif
}
}
public void OnSetup()
{
var container = new CryoContainer();
container.RegisterInstance(new Mock <IErrorMessageController>().Object);
container.RegisterSingleton <IPathfindingAlgorithm, AstarAlgorithm>();
_pathfindingAlgorithm = container.Resolve <IPathfindingAlgorithm>();
}
public Ghost(Grid grid, float size)
: base(grid, size)
{
_pathIterator = 0;
_behaviour = Behaviour.Patrol;
_patrolTime = patrolTime;
_chaseTime = chaseTime;
_returnTime = returnTime;
_chasePath = new List <Cell>();
_algorithm = new AStarAlgorithm();
}
public VaultBasedDungeonMapGenerator(ISystemContainer systemContainer, string floorCell, string wallCell, int numberOfVaults, int maxTries, double vaultChance, IEntity branch)
{
_systemContainer = systemContainer;
_floorCell = systemContainer.PrototypeSystem.Get(floorCell);
_wallCell = systemContainer.PrototypeSystem.Get(wallCell);
_numberOfVaults = numberOfVaults;
_branch = branch;
_maxTries = maxTries;
_lineDrawing = new BresenhamLineDrawingAlgorithm();
_tunnelPathfinding = new AStarPathfindingAlgorithm(false, PassableToTunneling, 500);
_vaultChance = vaultChance;
}
/// <summary>
/// Executes the pipeline on the Unity main thread.
/// </summary>
/// <param name="inInput">Input parameters for the path.</param>
private NavTilePath DoLinearPipeline(FindPathInput inInput)
{
if (_algorithm == null)
{
Type algorithm = Type.GetType(AlgorithmType);
_algorithm = Activator.CreateInstance(algorithm) as IPathfindingAlgorithm;
}
NavTilePath path = _algorithm.FindPath(inInput);
foreach (var smoothingAlgorithm in EnabledSmoothingAlgorithms)
{
var instance = Activator.CreateInstance(Type.GetType(smoothingAlgorithm)) as INavTilePathModifier;
path = instance.ModifyPath(path);
}
return(path);
}
public Task <ScenarioResult> BeginRunScenario(IScenario scenario, IPathfindingAlgorithm Algorithm)
{
if (!scenario.IsSet)
{
return(Task <ScenarioResult> .Factory.StartNew(() =>
{
return CreateNonSetResult(scenario);
}));
}
var taskRun = Task <INode> .Factory.StartNew(() =>
{
return(Algorithm.Resolve(scenario));
});
return(taskRun.ContinueWith((prevTask) =>
{
return CreateResultFrom(scenario, taskRun.Result);
}));
}
static PathFinder()
{
Algorithm = new AStarAlgorithm();
}
public PositionSystem(IMapSystem mapSystem, IEntityEngine entityEngine, IPathfindingAlgorithm pathfindingAlgorithm)
{
_mapSystem = mapSystem;
_entityEngine = entityEngine;
_pathfindingAlgorithm = pathfindingAlgorithm;
}
/// <summary>
/// Set the currently used algorithm to the type given.
/// </summary>
/// <typeparam name="T">Type of the algorithm class. Has to implement IPathfindingAlgorithm.</typeparam>
public void SetAlgorithm <T>() where T : IPathfindingAlgorithm
{
AlgorithmType = typeof(T).AssemblyQualifiedName;
_algorithm = null;
}
private static PositionSystem SetUpTestPositionSystemWithPathfindingAlgorithm(out IPathfindingAlgorithm pathfindingAlgorithm)
{
pathfindingAlgorithm = Substitute.For <IPathfindingAlgorithm>();
IEntityEngine entityEngine = Substitute.For <IEntityEngine>();
IMapSystem mapSystem = Substitute.For <IMapSystem>();
mapSystem.MapCollection.Returns(new Atlas()
{
{ new MapKey(TEST_MAP_NAME), Substitute.For <IMap>() }
});
var testPositionSystem = new PositionSystem(mapSystem, entityEngine, pathfindingAlgorithm);
return(testPositionSystem);
}
