public PathData GetPath(ContentItem item, string remainingUrl)
{
int slashIndex = remainingUrl.IndexOf('/');
string action = remainingUrl;
string arguments = null;
if(slashIndex > 0)
{
action = remainingUrl.Substring(0, slashIndex);
arguments = remainingUrl.Substring(slashIndex + 1);
}
var controllerName = this.controllerName ?? controllerMapper.GetControllerName(item.GetContentType());
if (string.IsNullOrEmpty(action) || string.Equals(action, "Default.aspx", StringComparison.InvariantCultureIgnoreCase))
action = "Index";
foreach (string method in methods)
{
if (string.Equals(method, action, StringComparison.InvariantCultureIgnoreCase))
{
var pd = new PathData(item)
{
IsRewritable = false,
Controller = controllerName,
Action = action,
Argument = arguments,
TemplateUrl = string.Format("~/{0}/{1}", controllerName, method, item.ID) // workaround for start pages
};
return pd;
}
}
return null;
}
public static PathData FindPath(PathFinderPoint start, PathFinderPoint end)
{
var path = pathfinder.FindPath(start, end);
var pathData = new PathData(path);
return pathData;
}
public void Page_With_Default_Action(string virtualUrl) {
// Arrange
var pathData = new PathData();
var mapper = new Mock<IControllerMapper>();
var container = new Mock<IContainer>();
mapper.Setup(x => x.GetControllerName(typeof(DummyController))).Returns("Dummy");
container.Setup(x => x.GetInstance<IDocumentSession>()).Returns(_store.OpenSession());
mapper.Setup(x => x.ControllerHasAction("Dummy", "index")).Returns(true);
// Act
IPathData data;
using (var session = _store.OpenSession()) {
// create and store a new page
var pageModel = new StandardPage { Metadata = { Url = "page" } };
session.Store(pageModel);
session.SaveChanges();
var resolver = new PathResolver(session, pathData, mapper.Object, container.Object);
data = resolver.ResolvePath(new RouteData(), virtualUrl);
}
// Assert
Assert.NotNull(data);
Assert.AreEqual("index", data.Action);
Assert.AreEqual("Dummy", data.Controller);
}
public ToolPath CreateToolPath(PathData pd, double inc)
{
ToolPath tp;
Barrel b = pd as Barrel;
tp = new ToolPath(b.BarrelOutline((int)(1/inc)));
return tp;
}
public static PathData FindPath(PathFinderPoint start, PathFinderPoint end, Vector2 offset)
{
var path = pathfinder.FindPath(start, end);
var pathData = new PathData(path, offset);
return pathData;
}
public ToolPath CreateToolPath(PathData pd, double inc)
{
ToolPath tp;
WheelsData rd = (WheelsData)pd;
tp = new ToolPath(CalculateWheels(rd, inc));
return tp;
}
public ShapeCollection CreatePaths(PathData pathdata, double inc)
{
ShapeCollection pc = new ShapeCollection();
pc.PatternName = pathdata.Name;
pc.AddShape(Path(pathdata, inc));
return pc;
}
public ToolPath CreateToolPath(PathData pd, double inc)
{
ToolPath tp;
BraidData b = pd as BraidData;
tp = new ToolPath(); //.BarrelOutline((int)(1 / inc)));
return tp;
}
private string CreateItem(TemplateDefinition template, NameValueCollection request)
{
var path = new PathData(navigator.Navigate(request["below"]));
if (!versionRepository.TryParseVersion(request[PathData.VersionIndexQueryKey], request[PathData.VersionKeyQueryKey], path))
path.CurrentItem = versions.AddVersion(path.CurrentItem, asPreviousVersion: false);
var parent = path.CurrentItem;
ContentItem item = activator.CreateInstance(template.Definition.ItemType, parent);
item.ZoneName = request["zone"];
item.TemplateKey = template.Name;
string beforeVersionKey = request["beforeVersionKey"];
string beforeSortOrder = request["beforeSortOrder"];
string before = request["before"];
if (string.IsNullOrEmpty(beforeSortOrder))
{
item.AddTo(parent);
}
else
{
int index = int.Parse(beforeSortOrder);
parent.InsertChildBefore(item, index);
}
versionRepository.Save(parent);
return request["returnUrl"].ToUrl().SetQueryParameter(PathData.VersionIndexQueryKey, parent.VersionIndex);
}
public SplineData(EditorItemSelection selectionManager)
: base(selectionManager)
{
splineData = new PathData();
selectionManager.SelectionChanged += selectionManager_SelectionChanged;
vertexHelper.PointChanged += vertexHelper_PointChanged;
}
public SplineData(PathData splineData, EditorItemSelection selectionManager)
: base(selectionManager)
{
this.splineData = splineData;
selectionManager.SelectionChanged += selectionManager_SelectionChanged;
vertexHelper.PointChanged += vertexHelper_PointChanged;
}
public ToolPath CreateToolPath(PathData pd, double inc)
{
BazelyChuck chuck = (pd as BazelyChuck);
if (chuck.Stages.Count == 1)
return new ToolPath(OneStagePath(chuck, inc));
else
return new ToolPath(TwoStagePath(chuck, inc));
}
public ToolPath CreateToolPath(PathData pd, double inc)
{
ToolPath tp;
RossData rd = (RossData)pd;
if (rd.Ex2 == 0)
tp = new ToolPath(RossCalculate1(rd, inc));
else
tp = new ToolPath(RossCalculate2(rd, inc));
tp.Translate(tp.Extent.Centre);
return tp;
}
/// <summary>
/// In this class the second parameter is the number of paths
/// </summary>
/// <param name="pathdata"></param>
/// <param name="increment"></param>
/// <returns></returns>
public ShapeCollection CreatePaths(PathData pathdata, double increment)
{
ShapeCollection pc = new ShapeCollection();
pc.PatternName = pathdata.Name;
if (pathdata.PathType == PatternType.barrel)
{
Barrel b = pathdata as Barrel;
RadialOffsetPath path = b.OutlineAsOffsets((int)(1/increment));
Polygon poly = CreatePolygonFrom(path, b.ToolPosition);
(poly.RenderTransform as CompositeTransform).Rotation = b.Phase;
pc.AddShape(poly);
}
return pc;
}
public ShapeCollection CreatePaths(PathData p, double increment)
{
ShapeCollection pc = new ShapeCollection();
if (p == null || !(p is LatticeData)) return pc;
ld = p as LatticeData;
rowHeight = ld.Layout.Height / (ld.Rows - 1);
colWidth = ld.Layout.Width / (ld.Columns - 1);
//Shape s = MkPath(0, 0, increment);
//if (s != null)
// pc.AddShape(s);
if ((ld.Layout.RepeatX == 0) && (ld.Layout.RepeatY == 0))
{
pc.AddShape(MkPath(0, 0, increment));
}
else if ((ld.Layout.RepeatX == 0) && (ld.Layout.RepeatY > 0))
{
for (int indy = -ld.Layout.RepeatY; indy < ld.Layout.RepeatY; indy++)
{
Shape s = MkPath(0, indy, increment);
if (s != null)
pc.AddShape(s);
}
}
else if ((ld.Layout.RepeatX > 0) && (ld.Layout.RepeatY == 0))
{
for (int indx = -ld.Layout.RepeatX; indx < ld.Layout.RepeatX; indx++)
{
Shape s = MkPath(indx, 0, increment);
if (s != null)
pc.AddShape(s);
}
}
else
{
for (int indy = -ld.Layout.RepeatY; indy < ld.Layout.RepeatY; indy++)
{
for (int indx = -ld.Layout.RepeatX; indx < ld.Layout.RepeatX; indx++)
{
Shape s = MkPath(indx, indy, increment);
if (s != null)
pc.AddShape(s);
}
}
}
return pc;
}
public ShapeCollection CreatePaths(PathData p, double increment)
{
ShapeCollection pc = new ShapeCollection();
if (p == null || !(p is LatticeData)) return pc;
ld = p as LatticeData;
repeatAngle = 360.0 / ld.Layout.RepeatX;
colAngle = (repeatAngle - ld.Layout.Margin) / (ld.Columns - 1);
rowHeight = ld.Layout.Height / (ld.Rows - 1);
colWidth = ld.Layout.Width / (ld.Columns - 1);
origin = new Point(ld.Layout.ToolPosition, 0);
if ((ld.Layout.RepeatX == 0) && (ld.Layout.RepeatY == 0))
{
pc.AddShape(MkPath(0, 0, increment));
}
else if ((ld.Layout.RepeatX == 0) && (ld.Layout.RepeatY > 0))
{
for (int indy = -ld.Layout.RepeatY; indy < ld.Layout.RepeatY; indy++)
{
pc.AddShape(MkPath(0, indy, increment));
}
}
else if ((ld.Layout.RepeatX > 0) && (ld.Layout.RepeatY == 0))
{
for (int indx = -ld.Layout.RepeatX; indx < ld.Layout.RepeatX; indx++)
{
pc.AddShape(MkPath(indx, 0, increment));
}
}
else
{
for (int indy = -ld.Layout.RepeatY; indy < ld.Layout.RepeatY; indy++)
{
for (int indx = -ld.Layout.RepeatX; indx < ld.Layout.RepeatX; indx++)
{
pc.AddShape(MkPath(indx, indy, increment));
}
}
}
//for (int indx = 0; indx < ld.Layout.RepeatX; indx++)
//{
// pc.AddShape(MkPath(indx,increment));
//}
return pc;
}
Windows.UI.Xaml.Shapes.Polygon Path(PathData pd,
double inc)
{
CompositeTransform ct = new CompositeTransform();
ct.ScaleX = ct.ScaleY = 1;
Windows.UI.Xaml.Shapes.Polygon p = new Windows.UI.Xaml.Shapes.Polygon();
p.Stroke = new SolidColorBrush(Color.FromArgb(255, 255, 0, 0));
p.RenderTransform = ct;
if (!(pd is WheelsData))
return p;
WheelsData rd = (WheelsData)pd;
p.Points = CalculateWheels(rd, inc);
// now centre polygon
//CentrePolygon(ref p);
return p;
}
public ShapeCollection CreatePaths (PathData pathdata, double inc)
{
//Debug.WriteLine("BazelyEngine CreatePaths");
ShapeCollection pc = new ShapeCollection();
pc.PatternName = pathdata.Name;
Polygon poly = Path(pathdata, inc);
try
{
pc.AddShape(poly);
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
}
//Debug.WriteLine("End BazelyEngine CreatePaths");
return pc;
}
public ShapeCollection CreatePaths(PathData pd, double increment)
{
bd = pd as BraidData;
ShapeCollection pc = new ShapeCollection();
pc.PatternName = pd.Name;
repeatAngle = 2 * Math.PI / bd.Repeats;
colAngle = (repeatAngle - rad * bd.Margin) / bd.Perms.Count ;
rowHeight = bd.Width / (bd.NumStrands - 1);
colWidth = bd.Length / bd.Perms.Count;
origin = new Point(bd.ToolPosition, 0);
for (int indx = 0; indx < bd.Repeats; indx++)
{
pc.AddShape(MkPath(indx, increment));
}
return pc;
}
Windows.UI.Xaml.Shapes.Polygon Path(PathData pd, double inc)
{
Windows.UI.Xaml.Shapes.Polygon p = new Windows.UI.Xaml.Shapes.Polygon();
p.Tag = "Bazley";
//Debug.WriteLine("BazelyEngine Polygon Created");
p.Stroke = new SolidColorBrush(Color.FromArgb(255, 255, 0, 0));
p.RenderTransform = new CompositeTransform();
if (!(pd is BazelyChuck))
return p;
BazelyChuck chuck = (pd as BazelyChuck);
//Debug.WriteLine("BazelyEngine Calc Points");
if (chuck.Stages.Count == 1)
p.Points = OneStagePath(chuck, inc);
else
p.Points = TwoStagePath(chuck, inc);
//Debug.WriteLine("BazelyEngine Points created");
CentrePolygon(ref p);
return p;
}
/*
* Initializes a new PathData object as the starting point to fill with PathData information
*/
public void GenerateNewPathData()
{
currentPath = new PathData();
Debug.Log("Path created in recorder.");
}
void DumpPathData(PathData pathData)
{
int count = pathData.Points.Length;
for (int idx = 0; idx < count; idx++)
{
string info = PdfEncoders.Format("{0:X} {1:####0.000} {2:####0.000}", pathData.Types[idx], pathData.Points[idx].X, pathData.Points[idx].Y);
Debug.WriteLine(info, "PathData");
}
}
/// <summary>
/// Public constructor which constructs the GraphicShape using the information
/// provided with PathData parameter.
/// </summary>
/// <param name="pathData">
/// Contains data about shape body.
/// </param>
public GraphicShape(PathData pathData)
{
Initialize();
m_Path = new GraphicsPath(pathData.Points, pathData.Types);
m_Bounds = m_Path.GetBounds();
}
/// <summary>
/// Converts distance on source from absolute to relative position, respecting Clamping
/// </summary>
/// <param name="worldUnitDistance">distance in world units from the source start</param>
/// <returns>
/// relative distance (TF) in the range 0..1
/// </returns>
protected override float AbsoluteToRelative(float worldUnitDistance)
{
return(PathData.DistanceToF(worldUnitDistance));
}
public ToolPath CreateToolPath(PathData pd, double inc)
{
ToolPath tp;
LatticeData l = pd as LatticeData;
tp = new ToolPath(); //.BarrelOutline((int)(1 / inc)));
return tp;
}
/// <summary>
/// Converts distance on source from relative to absolute position, respecting Clamping
/// </summary>
/// <param name="relativeDistance">relative distance (TF) from the source start</param>
/// <returns>
/// distance in world units from the source start
/// </returns>
protected override float RelativeToAbsolute(float relativeDistance)
{
return(PathData.FToDistance(relativeDistance));
}
/// <summary>
/// Retrieve the source Orientation/Up-Vector for a given relative position
/// </summary>
/// <param name="tf">relative position</param>
/// <returns>
/// the Up-Vector
/// </returns>
protected override Vector3 GetOrientation(float tf)
{
return((Space == Space.World) ? Path.Module.Generator.transform.TransformDirection(PathData.InterpolateUp(tf)) : PathData.InterpolateUp(tf));
}
private void InitializePath(MyEnvironmentalParticle particle)
{
var pathData = new PathData();
if(pathData.PathPoints == null)
pathData.PathPoints = new Vector3D[PathData.PathPointCount+2];
var gravityDirection = Vector3D.Normalize(MyGravityProviderSystem.CalculateNaturalGravityInPoint(particle.Position));
pathData.PathPoints[1] = particle.Position - Vector3D.Normalize(MyGravityProviderSystem.CalculateNaturalGravityInPoint(particle.Position)) * MyRandom.Instance.NextFloat()*2.5f;
for (int index = 2; index < PathData.PathPointCount+1; ++index )
{
var pathLength = 5.0f;
Vector3D randomNormal = Vector3D.Normalize(new Vector3D(MyRandom.Instance.NextFloat(), MyRandom.Instance.NextFloat(), MyRandom.Instance.NextFloat()) * 2.0f - Vector3D.One);
pathData.PathPoints[index] = pathData.PathPoints[index-1] + randomNormal * (MyRandom.Instance.NextFloat() + 1.0f) * pathLength - gravityDirection / (float)index * pathLength;
}
pathData.PathPoints[0] = pathData.PathPoints[1] - gravityDirection;
pathData.PathPoints[PathData.PathPointCount + 1] = pathData.PathPoints[PathData.PathPointCount] + Vector3D.Normalize(pathData.PathPoints[PathData.PathPointCount] - pathData.PathPoints[PathData.PathPointCount - 1]);
particle.UserData = pathData; // TODO: Boxing
}
public bool FindPath(int startX, int startY, int targetX, int targetY, out PathData path)
{
//float startTime = Time.realtimeSinceStartup;
int onOpenList = 0,
parentXval = 0,
parentYval = 0,
a = 0, b = 0, m = 0, u = 0, v = 0,
temp = 0, numberOfOpenListItems = 0,
addedGCost = 0, tempGcost = 0,
tempx, pathX, pathY,
newOpenListItemID = 0,
mapWidth = settings.xCount,
mapHeight = settings.yCount;
bool corner = false;
bool found = false;
int[] openList = new int[settings.xCount * settings.yCount + 2];
int[,] whichList = new int[settings.xCount + 1, settings.yCount + 1];
int[] openX = new int[settings.xCount * settings.yCount + 2];
int[] openY = new int[settings.xCount * settings.yCount + 2];
int[,] parentX = new int[settings.xCount + 1, settings.yCount + 1];
int[,] parentY = new int[settings.xCount + 1, settings.yCount + 1];
int[] Fcost = new int[settings.xCount * settings.yCount + 2];
int[,] Gcost = new int[settings.xCount + 1, settings.yCount + 1];
int[] Hcost = new int[settings.xCount * settings.yCount + 2];
int pathLength = 0;
int pathLocation = 0;
int onClosedList = 10;
path = new PathData();
path.data = null;
path.length = 0;
path.found = false;
if (startX >= mapWidth || startX < 0) return false;
else if (startY >= mapHeight || startY < 0) return false;
else if (targetX >= mapWidth || targetX < 0) return false;
else if (targetY >= mapHeight || targetY < 0) return false;
if (startX == targetX && startY == targetY && pathLocation > 0) return false;
if (startX == targetX && startY == targetY && pathLocation == 0) return false;
if (!GetWalkability(targetX, targetY)) return false;
if (onClosedList > 1000000)
{
for (int x = 0; x < mapWidth; x++)
for (int y = 0; y < mapHeight; y++) whichList[x, y] = 0;
onClosedList = 10;
}
onClosedList = onClosedList + 2;
onOpenList = onClosedList - 1;
pathLength = 0;
pathLocation = 0;
Gcost[startX, startY] = 0;
numberOfOpenListItems = 1;
openList[1] = 1;
openX[1] = startX ; openY[1] = startY;
do
{
if (numberOfOpenListItems != 0)
{
parentXval = openX[openList[1]];
parentYval = openY[openList[1]];
whichList[parentXval, parentYval] = onClosedList;
numberOfOpenListItems = numberOfOpenListItems - 1;
openList[1] = openList[numberOfOpenListItems + 1];
v = 1;
do
{
u = v;
if (2 * u + 1 <= numberOfOpenListItems)
{
if (Fcost[openList[u]] >= Fcost[openList[2 * u]]) v = 2 * u;
if (Fcost[openList[v]] >= Fcost[openList[2 * u + 1]]) v = 2 * u + 1;
}
else
{
if (2 * u <= numberOfOpenListItems)
if (Fcost[openList[u]] >= Fcost[openList[2 * u]]) v = 2 * u;
}
if (u != v)
{
temp = openList[u];
openList[u] = openList[v];
openList[v] = temp;
}
else break;
} while (true);
for (b = parentYval - 1; b <= parentYval + 1; b++)
{
for (a = parentXval - 1; a <= parentXval + 1; a++)
{
if (a != -1 && b != -1 && a != mapWidth && b != mapHeight)
{
if (whichList[a, b] != onClosedList)
{
if (GetWalkability(a, b))
{
corner = true;
if (a == parentXval - 1)
{
if (b == parentYval - 1)
{
if (!GetWalkability(parentXval - 1, parentYval) ||
!GetWalkability(parentXval, parentYval - 1))
corner = false;
}
else if (b == parentYval + 1)
{
if (!GetWalkability(parentXval, parentYval + 1) ||
!GetWalkability(parentXval - 1, parentYval))
corner = false;
}
}
else if (a == parentXval + 1)
{
if (b == parentYval - 1)
{
if (!GetWalkability(parentXval, parentYval - 1) ||
!GetWalkability(parentXval + 1, parentYval))
corner = false;
}
else if (b == parentYval + 1)
{
if (!GetWalkability(parentXval + 1, parentYval) ||
!GetWalkability(parentXval, parentYval + 1))
corner = false;
}
}
if (corner == true)
{
if (whichList[a,b] != onOpenList)
{
newOpenListItemID = newOpenListItemID + 1;
m = numberOfOpenListItems + 1;
openList[m] = newOpenListItemID;
openX[newOpenListItemID] = a;
openY[newOpenListItemID] = b;
if (Mathf.Abs(a - parentXval) == 1 && Mathf.Abs(b - parentYval) == 1) addedGCost = 14;
else addedGCost = 10;
Gcost[a, b] = Gcost[parentXval, parentYval] + addedGCost;
Hcost[openList[m]] = 10 * (Mathf.Abs(a - targetX) + Mathf.Abs(b - targetY));
Fcost[openList[m]] = Gcost[a, b] + Hcost[openList[m]];
parentX[a, b] = parentXval;
parentY[a, b] = parentYval;
while (m != 1)
{
if (Fcost[openList[m]] <= Fcost[openList[m / 2]])
{
temp = openList[m / 2];
openList[m / 2] = openList[m];
openList[m] = temp;
m = m / 2;
} else break;
}
numberOfOpenListItems = numberOfOpenListItems + 1;
whichList[a, b] = onOpenList;
} else
{
if (Mathf.Abs(a-parentXval) == 1 && Mathf.Abs(b - parentYval) == 1) addedGCost = 14;
else addedGCost = 10;
tempGcost = Gcost[parentXval, parentYval] + addedGCost;
if (tempGcost < Gcost[a, b])
{
parentX[a, b] = parentXval;
parentY[a, b] = parentYval;
Gcost[a, b] = tempGcost;
for (int x = 1; x <= numberOfOpenListItems; x++)
{
if (openX[openList[x]] == a && openY[openList[x]] == b) //item found
{
Fcost[openList[x]] = Gcost[a, b] + Hcost[openList[x]];
m = x;
while (m != 1)
{
if (Fcost[openList[m]] < Fcost[openList[m / 2]])
{
temp = openList[m / 2];
openList[m / 2] = openList[m];
openList[m] = temp;
m = m / 2;
}
else
break;
}
break;
}
}
}
}
}
}
}
}
}
}
} else { found = false; break; }
if (whichList[targetX, targetY] == onOpenList) { found = true; break; }
}
while (true);
if (found)
{
path.found = true;
pathX = targetX; pathY = targetY;
do
{
tempx = parentX[pathX, pathY];
pathY = parentY[pathX, pathY];
pathX = tempx;
pathLength = pathLength + 1;
}
while (pathX != startX || pathY != startY);
path.length = pathLength + 1;
path.data = new PATile[pathLength + 1];
path.data[0] = GetTile(startX, startY);
pathX = targetX ; pathY = targetY;
int ind = pathLength;
do
{
path.data[ind] = GetTile(pathX, pathY);
ind--;
tempx = parentX[pathX,pathY];
pathY = parentY[pathX,pathY];
pathX = tempx;
}
while (pathX != startX || pathY != startY);
}
return found;
}
public void UpdateData(PathData path)
{
ShapeLayer.UpdateShape(path.Data);
ShapeLayer.UpdateFillMode(path == null ? false : path.IsNonzeroFillRule);
}
/*
* Add a pathData element to the records
*/
public void AddPathRecord(PathData pathData)
{
pathRecords.Add(pathData);
}
private async Task DeleteAsync(MusicDb db, PathData pd)
{
db.ChangeTracker.AutoDetectChangesEnabled = false;
taskItem = await db.TaskItems.FindAsync(taskId);
IEnumerable <MusicFile> musicFileList = null;
string path = "";
if (pd.GetFullOpusPath() != null)
{
path = pd.IsCollections ? pd.OpusPath : $"{pd.ArtistPath}\\{pd.OpusPath}";
musicFileList = db.MusicFiles
.Where(f => (f.DiskRoot.ToLower() == pd.DiskRoot.ToLower()) &&
(f.StylePath.ToLower() == pd.StylePath.ToLower()) &&
(f.OpusPath.ToLower() == path.ToLower()))
.OrderBy(f => f.File)
;
}
else
{
if (pd.IsCollections)
{
musicFileList = db.MusicFiles
.Where(f => (f.DiskRoot.ToLower() == pd.DiskRoot.ToLower()) &&
(f.StylePath.ToLower() == pd.StylePath.ToLower()) &&
f.Musician.ToLower() == "collections")
.OrderBy(f => f.File)
;
}
else
{
musicFileList = db.MusicFiles
.Where(f => (f.DiskRoot.ToLower() == pd.DiskRoot.ToLower()) &&
(f.StylePath.ToLower() == pd.StylePath.ToLower()) &&
f.OpusPath.StartsWith(pd.ArtistPath))
.OrderBy(f => f.File)
;
}
}
log.Information($"Deleting {musicFileList.Count()} music files");
var dc = new DeleteContext(taskItem);
foreach (var mf in musicFileList)
{
db.Delete(mf, dc);
}
taskItem.Status = Music.Core.TaskStatus.Finished;
taskItem.FinishedAt = DateTimeOffset.Now;
await db.SaveChangesAsync();
if (dc.DeletedArtistId.HasValue)
{
await this.playManager.SendArtistDeleted(dc.DeletedArtistId.Value);
}
else if (dc.ModifiedArtistId.HasValue)
{
var shouldSend = true;
var artist = await db.Artists.FindAsync(dc.ModifiedArtistId.Value);
if (artist != null)
{
shouldSend = artist.Type != ArtistType.Various;
}
if (shouldSend)
{
await this.playManager.SendArtistNewOrModified(dc.ModifiedArtistId.Value);
}
}
//if (dc.DeletedArtistId.HasValue || dc.ModifiedArtistId.HasValue)
//{
// var shouldSend = true;
// var id = dc.ModifiedArtistId ?? 0;
// if (id > 0)
// {
// var artist = await db.Artists.FindAsync(id);
// shouldSend = artist.Type != ArtistType.Various;
// }
// if (shouldSend)
// {
// if (dc.DeletedArtistId.HasValue)
// {
// await this.playManager.SendArtistDeleted(dc.DeletedArtistId.Value);
// }
// else if (dc.ModifiedArtistId.HasValue)
// {
// await this.playManager.SendArtistNewOrModified(dc.ModifiedArtistId.Value);
// }
// }
//}
// send artist modified/deleted - info is in dc
}
/*
* Sets the current path to determine which PathData to currently be adding data to
*/
public void SetCurrentPath(PathData path)
{
currentPath = path;
}
private static void Reroute(Route r, AncientPortal closest, AncientPortal destination)
{
Sim target = r.Follower.Target as Sim;
Vector3 currentStartPoint = r.GetCurrentStartPoint();
float distanceRemaining = r.GetDistanceRemaining();
Common.StringBuilder msg = new Common.StringBuilder();
msg.Append("AncientPortal Reroute: " + target.FullName);
Route routeToPortal = target.CreateRoute();
routeToPortal.SetOption(Route.RouteOption.EnableSubwayPlanning, false);
routeToPortal.SetOption2(Route.RouteOption2.EnableHoverTrainPlanning, false);
routeToPortal.SetOption(Route.RouteOption.EnablePlanningAsCar, r.GetOption(Route.RouteOption.EnablePlanningAsCar));
routeToPortal.SetOption(Route.RouteOption.PlanUsingStroller, r.GetOption(Route.RouteOption.PlanUsingStroller));
routeToPortal.SetOption(Route.RouteOption.ReplanUsingStroller, r.GetOption(Route.RouteOption.ReplanUsingStroller));
routeToPortal.SetOption(Route.RouteOption.BeginAsStroller, r.GetOption(Route.RouteOption.BeginAsStroller));
Vector3 slotPosition = closest.GetSlotPosition(closest.GetRoutingSlots()[0]);
Vector3 slotFoward = closest.GetForwardOfSlot(closest.GetRoutingSlots()[0]);
Vector3 farPosition = new Vector3(slotPosition);
farPosition.x -= slotFoward.x / 4f;
farPosition.y -= slotFoward.y / 4f;
RoutePlanResult result = routeToPortal.PlanToPoint(farPosition);
msg.Append(Common.NewLine + "Result: " + result);
if (result.Succeeded())
{
msg.Append(Common.NewLine + "D" + Common.NewLine + Routes.RouteToString(routeToPortal));
Route portalRoute = target.CreateRoute();
portalRoute.SetOption(Route.RouteOption.EnableSubwayPlanning, false);
portalRoute.SetOption2(Route.RouteOption2.EnableHoverTrainPlanning, false);
portalRoute.SetOption(Route.RouteOption.EnablePlanningAsCar, r.GetOption(Route.RouteOption.EnablePlanningAsCar));
portalRoute.SetOption(Route.RouteOption.PlanUsingStroller, r.GetOption(Route.RouteOption.PlanUsingStroller));
portalRoute.SetOption(Route.RouteOption.ReplanUsingStroller, r.GetOption(Route.RouteOption.ReplanUsingStroller));
portalRoute.SetOption(Route.RouteOption.BeginAsStroller, r.GetOption(Route.RouteOption.BeginAsStroller));
result = portalRoute.PlanToPointFromPoint(slotPosition, farPosition);
msg.Append(Common.NewLine + "Result: " + result);
if (result.Succeeded())
{
PathData portalData = new PathData();
portalData.PathType = PathType.PortalPath;
portalData.ObjectId = closest.ObjectId;
portalData.PortalStartPos = slotPosition;
portalRoute.SetPathData(ref portalData);
msg.Append(Common.NewLine + "A" + Common.NewLine + Routes.RouteToString(portalRoute));
slotPosition = destination.GetSlotPosition(destination.GetRoutingSlots()[0]);
r.SetOption(Route.RouteOption.EnableSubwayPlanning, false);
if (!r.ReplanFromPoint(slotPosition).Succeeded())
{
r.ReplanFromPoint(currentStartPoint);
}
else if ((routeToPortal.GetDistanceRemaining() + r.GetDistanceRemaining()) < (distanceRemaining + SimRoutingComponent.kDistanceMustSaveInOrderToUseSubway))
{
AncientPortalComponent.AddTargetPortal(target, destination);
msg.Append(Common.NewLine + "B" + Common.NewLine + Routes.RouteToString(r));
r.InsertRouteSubPathsAtIndex(0x0, portalRoute);
r.InsertRouteSubPathsAtIndex(0x0, routeToPortal);
msg.Append(Common.NewLine + "C" + Common.NewLine + Routes.RouteToString(r));
r.SetOption(Route.RouteOption.EnableSubwayPlanning, true);
}
else
{
r.ReplanFromPoint(currentStartPoint);
}
}
}
Common.DebugNotify(msg, target);
Common.DebugWriteLog(msg);
}
public void Instance_GetsTemplateUrl_FromDefinition_WhenDefined()
{
PathData path = item.FindPath(PathData.DefaultAction);
Assert.That(path.TemplateUrl, Is.EqualTo("~/My/Template.ascx"));
}
private void OptionSelected()
{
pathData = new PathData(webService.Context);
webService.Data = pathData;
string message = "<html>";
if (pathData.Funcio == "favicon.ico")
{
return;
}
if (pathData.Funcio != "stop" && pathData.Funcio != "veuretauler" && pathData.Funcio != "marcarcasella" && pathData.Funcio != "reset")
{
throw new BadFunctionException();
}
if ((pathData.Jugador == null || pathData.Columna == default(int) || pathData.Fila == default(int)) && pathData.Funcio == "marcarcasella")
{
throw new ParametersException();
}
if (pathData.Funcio == "stop")
{
webService.Stop();
}
else
{
if (pathData.Funcio == "veuretauler")
{
message += VeureTauler();
}
else if (pathData.Funcio == "marcarcasella")
{
message = "<head><meta charset=\"UTF-8\"><title>Marcar Casella</title></head><body>";
if (Convert.ToChar(pathData.Jugador) != 'x' && Convert.ToChar(pathData.Jugador) != 'o')
{
throw new JugadorException();
}
else if (pathData.Fila > 3 || pathData.Fila < 1)
{
throw new FilaIncorrecteException();
}
else if (pathData.Columna > 3 || pathData.Columna < 1)
{
throw new ColumnaIncorrecteException();
}
else
{
if (tresEnRatlla.PartidaAcabada)
{
message += "La partida ja esta acabada";
}
else
{
if (tresEnRatlla.SeguentJugador == Convert.ToChar(pathData.Jugador))
{
bool canviat = tresEnRatlla.MarcarCasella(pathData.Fila - 1, pathData.Columna - 1, Convert.ToChar(pathData.Jugador));
if (!canviat)
{
message += "La casella ja està marcada";
}
else
{
message += VeureTauler();
if (tresEnRatlla.Guanyador != '-')
{
message += "<p style=\"font-size:30px\">El guanyador és: " + tresEnRatlla.Guanyador + "</p>";
VeureTauler();
}
}
}
else
{
message += "Aquest no es el teu torn";
}
}
message += "</body>";
}
}
else if (pathData.Funcio == "reset")
{
tresEnRatlla.Reset();
message += "<script>alert(\"Tauler reiniciat!!!\");</script>";
message += VeureTauler();
}
message += "</html>";
webService.Message = message;
}
}
private void UpdateItemFromTopEditor(PathData path)
{
var editor = FindTopEditor(Parent);
var draftOfTopEditor = path.CurrentPage.FindPartVersion(editor.CurrentItem);
editor.UpdateObject(new Edit.Workflow.CommandContext(editor.Definition, draftOfTopEditor, Interfaces.Editing, Context.User));
}
/// <summary>
/// Retrieve the source position for a given relative position (TF)
/// </summary>
/// <param name="tf">relative position</param>
/// <returns>
/// a world position
/// </returns>
protected override Vector3 GetInterpolatedSourcePosition(float tf)
{
return((Space == Space.World) ? Path.Module.Generator.transform.TransformPoint(PathData.InterpolatePosition(tf)) : PathData.InterpolatePosition(tf));
}
private static PathData UseItemIfAvailable(ContentItem item, PathData data)
{
if (item != null)
{
data.CurrentPage = data.CurrentItem;
data.CurrentItem = item;
}
return data;
}
/// <exception cref="System.IO.IOException"/>
protected internal override InputStream GetInputStream(PathData item)
{
return(base.GetInputStream(item));
}
/// <summary>
/// Returns HTML for the navigation bar.
/// </summary>
private static string GenerateNavigationInfo(PathData currentPath, List<PathData> relatedPaths)
{
var names = new List<string>();
var links = new List<string>();
if (currentPath.FractalScale == 0)
{
// Dungeon and raid instances have their paths separated from each other.
// So paths have data only for one instance.
foreach (var path in relatedPaths)
{
if (path == null)
{
ErrorHandler.ShowWarningMessage("A path is not defined.");
continue;
}
names.Add(path.NavigationName);
links.Add(path.Filename);
}
}
else
{
// All fractal paths are mixed together so they require a different implementation.
// There are 100 paths so obviously not everything can be included in the small navigation bar.
// NOTE: relatedPaths indexing starts from 0 while scales start from 1.
var startingScale = currentPath.FractalScale - Constants.FractalNavPathCount / 2;
if (startingScale + Constants.FractalNavPathCount >= relatedPaths.Count)
startingScale = relatedPaths.Count - Constants.FractalNavPathCount;
if (startingScale < 1)
startingScale = 1;
for (var index = startingScale - 1; index < startingScale + Constants.FractalNavPathCount; index++)
{
if (currentPath.FractalScale == index + 1 || index >= relatedPaths.Count)
continue;
if (relatedPaths[index] == null)
{
ErrorHandler.ShowWarningMessage("Scale " + index + 1 + " is not defined.");
continue;
}
names.Add("Scale " + relatedPaths[index].FractalScale + ": " + relatedPaths[index].NavigationName);
links.Add(relatedPaths[index].Filename);
}
}
return string.Join("|", names) + Constants.ForcedLineEnding + string.Join("|", links) + Constants.ForcedLineEnding;
}
private void saveNewPathData(PathData data)
{
WarningSystem.addWarning("Attempt to Save Pathdata", "Shouldn't be called in render", Code.Error);
/*
XmlSerializer serializer = new XmlSerializer(typeof(PathData));
//string exeFolder = System.IO.Path.GetDirectoryName(Application.ExecutablePath);
TextWriter textWriter = new StreamWriter(activeProject.projectFolderPath + "\\paths\\" + data.pathName + ".xml");
serializer.Serialize(textWriter, data);
textWriter.Close();
*/
}
public ThreadContext()
{
currentPath = PathData.Empty;
items = new Hashtable();
url = "http://localhost/";
}
/// <summary>Applies the current content item and controller to the route data.</summary>
public static RouteData ApplyCurrentPath(RouteData data, string controllerName, string actionName, PathData path)
{
data.Values[ContentRoute.ControllerKey] = controllerName;
data.Values[ContentRoute.ActionKey] = actionName;
return(data.ApplyCurrentPath(path));
}
