protected override JobHandle OnUpdate(JobHandle inputDeps)
{
float deltaTime = Time.DeltaTime;
return(Entities.ForEach((Entity entity, DynamicBuffer <PathPosition> pathPositionBuffer, ref Translation translation, ref Rotation rotation, ref PathFollow pathFollow) =>
{
if (pathFollow.pathIndex >= 0)
{
// Получаем первую позицию
PathPosition pathPosition = pathPositionBuffer[pathFollow.pathIndex];
// Переводим ее координаты в мировые
float3 targetPosition = PathfindingGridSetup.Instance.pathfindingGrid.GetWorldPosition(pathPosition.position.x, pathPosition.position.y);
// Расчитываем направление и угол поворота
float3 moveDir = math.normalizesafe(targetPosition - translation.Value);
float moveSpeed = 3f;
float rotationSpeed = 5f;
var targetRotation = quaternion.LookRotation(targetPosition - translation.Value, new float3(0, 1, 0));
var newRotation = math.slerp(rotation.Value, math.mul(targetRotation, quaternion.Euler(-90 * Mathf.Deg2Rad, 0, 0)), deltaTime * rotationSpeed);
rotation.Value = newRotation;
translation.Value += moveDir * moveSpeed * deltaTime;
if (math.distance(translation.Value, targetPosition) < .1f)
{
// Next waypoint
pathFollow.pathIndex--;
}
}
}).Schedule(inputDeps));
}
public float move(PathPosition currentPosition, float distance, out PathPosition newPosition)
{
float distToEnd = (points.Length - 1 - currentPosition.pointIndex - currentPosition.ratio) * distanceBetweenPoints;
float distToStart = (currentPosition.pointIndex + currentPosition.ratio) * distanceBetweenPoints;
if (distance - distToEnd > 0)
{
newPosition = getEndPoint();
return(distance - distToEnd);
}
else if (distance + distToStart < 0)
{
newPosition = getStartPoint();
return(distance + distToStart);
}
distance += currentPosition.ratio * distanceBetweenPoints;
int tam = (int)(distance / distanceBetweenPoints);
float artan = distance / distanceBetweenPoints - tam;
if (artan < 0)
{
artan += 1f;
tam--;
}
newPosition = new PathPosition(currentPosition.pointIndex + tam, artan);
return(0);
}
public override PathPosition GetClosestPoint(Vector3 position, out float distanceSqr)
{
PathPosition pathPos = GetPoint(0.0f);
distanceSqr = (position - pathPos._pathPosition).sqrMagnitude;
return(pathPos);
}
public override PathPosition GetClosestPoint(Vector3 position, out float distanceSqr)
{
PathPosition closestPosition = null;
int numLines = _isLooping ? _nodes.Length : _nodes.Length - 1;
float linePathT = 1.0f / (float)(numLines);
distanceSqr = 0.0f;
for (int i = 0; i < numLines; i++)
{
//Get closest point on line
int toNode = (i < _nodes.Length - 1) ? i + 1 : 0;
float lineLerp = 0.0f;
float dist = 0.0f;
float width;
Vector3 up, forward;
Vector3 closestPoint = GetClosestPointToLine(i, toNode, position, out dist, out lineLerp, out forward, out up, out width);
if (closestPosition == null || dist < distanceSqr)
{
closestPosition = new PathPosition(this, ((float)i + lineLerp) * linePathT, closestPoint, forward, up, width);
distanceSqr = dist;
}
}
if (closestPosition == null)
{
closestPosition = null;
}
return(closestPosition);
}
public void AddPickupSerie(float startDistance, int amount, float absoluteStep, PathPosition pathPos)
{
for (int i = 0; i < amount; i++)
{
AddPickup(startDistance + i * (absoluteStep / totalDistance), pathPos);
}
}
/// <summary>
/// Verilen minionu boarda ekler. 2.Parametrede verilen noktaya goturur.
/// </summary>
/// <param name="minion">boarda yerlestirilecek minion</param>
/// <returns>Bu islem her zaman basarili oldugu icin bir return degeri yoktur.</returns>
public void AddMinionSpecificPosition(Minion minion, PathPosition position, bool notifyPlayers = true)
{
if (boardState != BoardState.COLLAPSING)
{
try
{
toBeAddedMinions.Add(minion);
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace + " : " + e.Message);
}
if (minion.position == null)
{
minion.position = new MinionPosition();
}
minion.position.board = this;
minion.position.pathPosition = new PathPosition(position.pointIndex, position.ratio);
if (notifyPlayers)
{
Messages.OutgoingMessages.Game.GMinionPositionInfo.sendMessage(player.game.players, minion);
}
}
else
{
minion.destroyable = true;
Messages.OutgoingMessages.Game.GDestroyMinionInfo.sendMessage(player.game.players, minion);
}
}
protected override void OnUpdate()
{
float deltaTime = Time.DeltaTime;
float cellSize = Testing.Instance.grid.GetCellSize();
Entities.ForEach((Entity entity, DynamicBuffer <PathPosition> pathPositionBuffer, ref Translation translation, ref PathFollow pathFollow) => {
if (pathFollow.pathIndex >= 0)
{
// Has path to follow
PathPosition pathPosition = pathPositionBuffer[pathFollow.pathIndex];
float3 targetPosition = new float3(pathPosition.position.x * cellSize + cellSize * 0.5f, pathPosition.position.y * cellSize + cellSize * 0.5f, 0);
float3 moveDir = math.normalizesafe(targetPosition - translation.Value);
float moveSpeed = 1f;
translation.Value += moveDir * moveSpeed * deltaTime;
if (math.distance(translation.Value, targetPosition) < cellSize * .25f)
{
// Next waypoint
pathFollow.pathIndex--;
}
}
}).ScheduleParallel();
}
public override float GetDistanceBetween(float fromT, float toT)
{
ClampPathT(ref fromT, ref toT);
float distance = 0.0f;
int numSamples = (int)Mathf.Ceil(Mathf.Abs(toT - fromT) * kNumSamples);
float sampleT = (toT > fromT ? 1.0f : -1.0f) / (float)kNumSamples;
float pathT = fromT;
PathPosition pathPosition = GetPoint(fromT);
for (int i = 0; i < numSamples; i++)
{
if (i == numSamples - 1)
{
pathT = toT;
}
else
{
pathT += sampleT;
}
PathPosition samplePos = GetPoint(pathT);
Vector3 toSamplePos = samplePos._pathPosition - pathPosition._pathPosition;
distance += toSamplePos.magnitude;
pathPosition = samplePos;
}
return(distance);
}
public static PathRoute FindRoute(PathPosition startPos, PathPosition endPos)
{
if (startPos == null || endPos == null || startPos._path == null || endPos._path == null)
{
return(null);
}
PathRoute bestRoute = null;
List <PathNode> linkedNodes = new List <PathNode>();
PathNode nodeA = GetNextNode(startPos, Direction1D.Forwards);
if (nodeA != null && nodeA.isActiveAndEnabled)
{
linkedNodes.Add(nodeA);
}
PathNode nodeB = GetNextNode(startPos, Direction1D.Backwards);
if (nodeB != null && nodeA != nodeB && nodeB.isActiveAndEnabled)
{
linkedNodes.Add(nodeB);
}
List <PathNode> traversedNodes = new List <PathNode>();
FindRoute(startPos, endPos, startPos._path, startPos._pathT, linkedNodes, 0.0f, new List <PathRouteWaypoint>(), ref bestRoute, ref traversedNodes);
return(bestRoute);
}
public static PathPosition GetClosestPoint(Path startPath, Ray ray)
{
PathPosition closestPoint = null;
if (startPath != null)
{
//Traverse path network and work out nearest point
List <Path> paths = new List <Path>();
paths.Add(startPath);
FindPaths(startPath, ref paths);
float bestDist = 0.0f;
//for each path find closest point and get connected paths
foreach (Path path in paths)
{
float distanceSqr;
PathPosition pathClosestPoint = path.GetClosestPoint(ray, out distanceSqr);
if (closestPoint == null || distanceSqr < bestDist)
{
closestPoint = pathClosestPoint;
bestDist = distanceSqr;
}
}
}
return(closestPoint);
}
public override PathPosition GetClosestPoint(Vector3 position, out float sqrMagnitude)
{
PathPosition closestPosition = null;
float sampleT = 1.0f / (float)kNumSamples;
float pathT = 0.0f;
sqrMagnitude = 0.0f;
for (int i = 0; i < kNumSamples; i++)
{
PathPosition samplePos = GetPoint(pathT);
Vector3 toSamplePos = samplePos._pathPosition - position;
float posDistance = toSamplePos.sqrMagnitude;
if (closestPosition == null || posDistance < sqrMagnitude)
{
closestPosition = samplePos;
sqrMagnitude = posDistance;
}
pathT += sampleT;
}
return(closestPosition);
}
public PathPosition GetPointAtDistance(float distance)
{
PathPosition pathPosition = new PathPosition(_startPosition);
float targetT = _endPosition._pathT;
//If the path has waypoints, travel along them
for (int i = 0; i < _waypoints.Length; i++)
{
float waypointPathT = pathPosition._path.GetPathT(_waypoints[i]._pathNode);
float distToWaypoint = pathPosition._path.GetDistanceBetween(pathPosition._pathT, waypointPathT);
pathPosition._path = _waypoints[i]._path;
pathPosition._pathT = _waypoints[i]._path.GetPathT(_waypoints[i]._pathNode);
//if next waypoint is less than distance away, move towards this waypoint instead of path end
if (distance < distToWaypoint)
{
targetT = waypointPathT;
break;
}
else
{
distance -= distToWaypoint;
i++;
}
}
//Find new position
pathPosition = pathPosition._path.TravelPath(pathPosition._pathT, targetT, distance);
return(pathPosition);
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
float deltaTime = Time.DeltaTime;
return(Entities.ForEach((Entity entity, DynamicBuffer <PathPosition> pathPositionBuffer, ref DeathComponent _dead, ref Translation translation, ref Rotation rot, ref PathFollow pathFollow, ref MovementComponent _move, ref IDComponent _id) =>
{
rot.Value = new quaternion(0, 0, 0, 1);
if (pathFollow.pathIndex >= 0 && _move.isMoving && _dead.isDead == false)
{
// Has path to follow
PathPosition pathPosition = pathPositionBuffer[pathFollow.pathIndex];
float3 targetPosition = new float3((pathPosition.position.x + .5f) * 0.32f, (pathPosition.position.y + .5f) * 0.32f, 0);
float3 moveDir = math.normalizesafe(targetPosition - translation.Value);
translation.Value += moveDir * _move.speed * deltaTime;
float3 myXy = translation.Value;
//Debug.Log(_id.id);
//GameController.Instance.SetPosition(_id.id, myXy.x, myXy.y);
if (math.distance(translation.Value, targetPosition) < .1f)
{
// Next waypoint
pathFollow.pathIndex--;
}
}
else
{
_move.isMoving = false;
}
}).Schedule(inputDeps));
}
public override PathPosition GetClosestPoint(Ray ray, out float distanceSqr)
{
PathPosition pathPos = GetPoint(0.0f);
//TO DO! Should return distance between closest point on ray and position
distanceSqr = (ray.origin - pathPos._pathPosition).sqrMagnitude;
return(pathPos);
}
public PathPosition(PathPosition other)
{
_path = other._path;
_pathT = other._pathT;
_pathNode = other._pathNode;
_pathPosition = other._pathPosition;
_pathForward = other._pathForward;
_pathUp = other._pathUp;
_pathWidth = other._pathWidth;
}
public static void DrawPathPosGizmo(PathPosition position, Color color)
{
if (position != null)
{
Color origColor = UnityEditor.Handles.color;
UnityEditor.Handles.color = color;
UnityEditor.Handles.SphereHandleCap(2, position._pathPosition, Quaternion.identity, 0.1f, EventType.Repaint);
UnityEditor.Handles.color = origColor;
}
}
public override void ProcessFrame(Playable playable, FrameData info, object playerData)
{
_trackBinding = playerData as Transform;
if (_trackBinding == null)
return;
if (_firstFrame)
{
_defaultPosition = _trackBinding.position;
_defaultRotation = _trackBinding.rotation;
_firstFrame = false;
}
Vector3 position = _defaultPosition;
Quaternion rotation = _defaultRotation;
int numInputs = playable.GetInputCount();
for (int i = 0; i < numInputs; i++)
{
ScriptPlayable<PathPlayableBehaviour> scriptPlayable = (ScriptPlayable<PathPlayableBehaviour>)playable.GetInput(i);
PathPlayableBehaviour inputBehaviour = scriptPlayable.GetBehaviour();
if (inputBehaviour != null && inputBehaviour._path != null)
{
float inputWeight = playable.GetInputWeight(i);
if (inputWeight > 0.0f)
{
TimelineClip clip = TimelineUtils.GetClip(_trackAsset, inputBehaviour._clipAsset);
if (clip != null)
{
double clipStart = clip.hasPreExtrapolation ? clip.extrapolatedStart : clip.start;
double clipDuration = clip.hasPreExtrapolation || clip.hasPostExtrapolation ? clip.extrapolatedDuration : clip.duration;
if (_director.time >= clipStart && _director.time <= clipStart + clipDuration)
{
//To do handle loops etc
double t = Mathf.Clamp01((float)(_director.time - clip.start) / (float)clip.duration);
PathPosition pos = inputBehaviour._path.GetPoint((float)t);
position = Vector3.Lerp(position, pos._pathPosition, inputWeight);
rotation = Quaternion.Slerp(rotation, Quaternion.LookRotation(pos._pathForward, pos._pathUp), inputWeight);
}
}
}
}
}
_trackBinding.position = position;
_trackBinding.rotation = rotation;
}
/// <summary>
/// Calculates a point on the BezierPath
/// </summary>
/// <param name="curveIndex">On which bezier curve, your point is ? (Starts from 0)</param>
/// <param name="t">between 0 and 1 , specifies the point on the curve</param>
/// <returns>A Vector3 of the specified point</returns>
public Vector3 getLocalPosition(PathPosition position)
{
int nodeIndex = position.pointIndex;
Vector3 p0 = controlPoints[nodeIndex];
Vector3 p1 = controlPoints[nodeIndex + 1];
Vector3 p2 = controlPoints[nodeIndex + 2];
Vector3 p3 = controlPoints[nodeIndex + 3];
return(CalculateBezierPoint(position.ratio, p0, p1, p2, p3));
}
private Vector3 findDiffOnPath(PathPosition position)
{
int index = position.pointIndex;
Vector3 x = controlPoints[index];
Vector3 y = controlPoints[index + 1];
Vector3 z = controlPoints[index + 2];
Vector3 w = controlPoints[index + 3];
float t = position.ratio;
return(t * t * (-3 * x + 9 * y - 9 * z + 3 * w) + t * (6 * x - 12 * y + 6 * z) + (-3 * x + 3 * y));
}
public override PathPosition GetClosestPoint(Ray ray, out float distanceSqr)
{
PathPosition closestPosition = null;
int numLines = _isLooping ? _nodes.Length : _nodes.Length - 1;
float linePathT = 1.0f / (float)(numLines);
distanceSqr = 0.0f;
for (int i = 0; i < numLines; i++)
{
//THIS is wrong - path line should be of fixed length!
//Get closest point on line
int toNode = (i < _nodes.Length - 1) ? i + 1 : 0;
float lineLerp = 0.0f;
float dist;
Vector3 fromNodePos = GetNodePosition(i);
Vector3 toNodePos = GetNodePosition(toNode);
Vector3 closestPoint;
Vector3 pathLineDir = (toNodePos - fromNodePos).normalized;
if (MathUtils.ClosestPointsOnTwoLines(ray.origin, ray.direction, fromNodePos, pathLineDir, out _, out float closestPointPathLineT))
{
closestPoint = fromNodePos + pathLineDir * closestPointPathLineT;
Vector3 closestPointOnRay = ray.origin + ray.direction * closestPointPathLineT;
dist = (closestPointOnRay - closestPoint).sqrMagnitude;
}
//Lines are parallel - use start points of both lines
else
{
closestPoint = fromNodePos;
dist = (closestPoint - ray.origin).sqrMagnitude;
}
if (closestPosition == null || dist < distanceSqr)
{
Vector3 startNodeUp = GetNodeUp(i, pathLineDir);
Vector3 endNodeUp = GetNodeUp(toNode, pathLineDir);
closestPosition = new PathPosition(this, ((float)i + lineLerp) * linePathT, closestPoint,
pathLineDir,
Vector3.Lerp(startNodeUp, endNodeUp, lineLerp),
Mathf.Lerp(_nodes[i]._width, _nodes[toNode]._width, lineLerp));
distanceSqr = dist;
}
}
return(closestPosition);
}
//Function for moving
protected void Move()
{
//Entity data getting
Entity entity = convertedEntityHolder.GetEntity();
EntityManager entityManager = convertedEntityHolder.GetEntityManager();
if (entityManager == null)
{
return;
}
PathFollowComponent pathFollow = entityManager.GetComponentData <PathFollowComponent>(entity);
DynamicBuffer <PathPosition> pathPositionBuffer = entityManager.GetBuffer <PathPosition>(entity);
//If still following path
if (pathFollow.pathIndex >= 0)
{
//Get path position
PathPosition pathPosition = pathPositionBuffer[pathFollow.pathIndex];
//Get world position for each node
float3 targetPosition = new float3(pathPosition.position.x, 0, pathPosition.position.y) + Vector3.one * new float3(gridCellSize, 0, gridCellSize) * 0.5f;
//Calculate move direction
float3 moveDir = math.normalizesafe(targetPosition - (float3)transform.position);
//Move the ai to the next node
transform.position += (Vector3)(moveDir * (3f + unitSpeed) * Time.deltaTime);
//Check if within radius of next node
if (math.distance(transform.position, targetPosition) < movementStopDist)
{
//If reached destination
if (pathFollow.pathIndex == 0)
{
hasCompletedCurrentTask = true;
}
//Next node
pathFollow.pathIndex--;
//Update pathfollow array
entityManager.SetComponentData(entity, pathFollow);
}
}
//If current task completed
if (hasCompletedCurrentTask == true)
{
//Null pointer check for next task
if (nextTask != null)
{
//Invoke next task
nextTask.Invoke();
nextTask = null;
}
}
}
void OnEnable()
{
//lock transform
PathPosition pathPosition = target as PathPosition;
if (pathPosition.Path)
{
SetHideFlags();
}
Undo.undoRedoPerformed += UpdatePosition;
}
public void DebugDraw()
{
Color origColor = Handles.color;
Handles.color = _pathColor;
if (_nodes != null && _nodes.Length > 0)
{
float sampleT = 1.0f / (float)(_debugDrawPointCount - 1);
float pathT = 0.0f;
Vector3 prevPointA = Vector3.zero;
Vector3 prevPointB = Vector3.zero;
for (int i = 0; i < _debugDrawPointCount; i++)
{
PathPosition pos = GetPoint(pathT);
Vector3 pathRight = Vector3.Cross(pos._pathUp, pos._pathForward).normalized;
Vector3 pathHoriz = pathRight * (pos._pathWidth * 0.5f);
Vector3 pointA = pos._pathPosition - pathHoriz;
Vector3 pointB = pos._pathPosition + pathHoriz;
Handles.DrawLine(pointA, pointB);
if (i > 0)
{
Handles.DrawLine(prevPointA, pointA);
Handles.DrawLine(prevPointB, pointB);
}
prevPointA = pointA;
prevPointB = pointB;
pathT += sampleT;
}
//Draw node up directions
for (int i = 0; i < _nodes.Length; i++)
{
Quaternion nodeUpRotation = Quaternion.FromToRotation(Vector3.up, _nodes[i]._up);
Vector3 nodePos = GetNodePosition(i);
Vector3 controlPos = nodePos + nodeUpRotation * (Vector3.up * _nodes[i]._width);
Handles.DrawLine(nodePos, controlPos);
Handles.SphereHandleCap(0, controlPos, Quaternion.identity, _nodes[i]._width * 0.166f, EventType.Repaint);
}
Handles.color = origColor;
}
}
/// <summary>
/// Parses the root node of an XMP Path, checks if namespace and prefix fit together
/// and resolve the property to the base property if it is an alias.
/// </summary>
/// <param name="schemaNs">the root namespace</param>
/// <param name="pos">the parsing position helper</param>
/// <param name="expandedXPath">the path to contribute to</param>
/// <exception cref="XmpException">If the path is not valid.</exception>
private static void ParseRootNode(string schemaNs, PathPosition pos, XmpPath expandedXPath)
{
while (pos.StepEnd < pos.Path.Length && "/[*".IndexOf(pos.Path[pos.StepEnd]) < 0)
{
pos.StepEnd++;
}
if (pos.StepEnd == pos.StepBegin)
{
throw new XmpException("Empty initial XMPPath step", XmpErrorCode.BadXPath);
}
var rootProp = VerifyXPathRoot(schemaNs, pos.Path.Substring(pos.StepBegin, pos.StepEnd - pos.StepBegin));
var aliasInfo = XmpMetaFactory.SchemaRegistry.FindAlias(rootProp);
if (aliasInfo == null)
{
// add schema xpath step
expandedXPath.Add(new XmpPathSegment(schemaNs, XmpPathStepType.SchemaNode));
var rootStep = new XmpPathSegment(rootProp, XmpPathStepType.StructFieldStep);
expandedXPath.Add(rootStep);
return;
}
// add schema xpath step and base step of alias
expandedXPath.Add(new XmpPathSegment(aliasInfo.Namespace, XmpPathStepType.SchemaNode));
expandedXPath.Add(new XmpPathSegment(VerifyXPathRoot(aliasInfo.Namespace, aliasInfo.PropName), XmpPathStepType.StructFieldStep)
{
IsAlias = true,
AliasForm = aliasInfo.AliasForm.GetOptions()
});
if (aliasInfo.AliasForm.IsArrayAltText)
{
expandedXPath.Add(new XmpPathSegment("[?xml:lang='x-default']", XmpPathStepType.QualSelectorStep)
{
IsAlias = true,
AliasForm = aliasInfo.AliasForm.GetOptions()
});
}
else if (aliasInfo.AliasForm.IsArray)
{
expandedXPath.Add(new XmpPathSegment("[1]", XmpPathStepType.ArrayIndexStep)
{
IsAlias = true,
AliasForm = aliasInfo.AliasForm.GetOptions()
});
}
}
public override PathPosition TravelPath(float fromT, float toT, float distance)
{
ClampPathT(ref fromT);
ClampPathT(ref toT);
Direction1D direction = toT >= fromT ? Direction1D.Forwards : Direction1D.Backwards;
float sampleT = (direction == Direction1D.Forwards ? 1.0f : -1.0f) / (float)kNumSamples;
PathPosition pathPosition = GetPoint(fromT);
PathPosition samplePos = GetPoint(pathPosition._pathT + sampleT);
while (true)
{
Vector3 toSamplePos = samplePos._pathPosition - pathPosition._pathPosition;
float sampleDist = toSamplePos.magnitude;
if (distance <= sampleDist || sampleDist == 0.0f)
{
float distLerp = sampleDist <= 0f ? 0.0f : (distance / sampleDist);
pathPosition._pathPosition = pathPosition._pathPosition + (toSamplePos * distLerp);
pathPosition._pathForward = Vector3.Lerp(pathPosition._pathForward, samplePos._pathForward, distLerp);
pathPosition._pathUp = Vector3.Lerp(pathPosition._pathUp, samplePos._pathUp, distLerp);
pathPosition._pathT = pathPosition._pathT + (sampleT * distLerp);
pathPosition._pathWidth = Mathf.Lerp(pathPosition._pathWidth, samplePos._pathWidth, distLerp);
break;
}
else
{
distance -= sampleDist;
pathPosition._pathT += sampleT;
pathPosition._pathPosition = samplePos._pathPosition;
pathPosition._pathForward = samplePos._pathForward;
pathPosition._pathUp = samplePos._pathUp;
pathPosition._pathWidth = samplePos._pathWidth;
samplePos = GetPoint(pathPosition._pathT + sampleT);
}
}
//Face opposite direction if traveling backwards
if (direction == Direction1D.Backwards)
{
pathPosition._pathForward = Quaternion.AngleAxis(180f, pathPosition._pathUp) * pathPosition._pathForward;
}
return(pathPosition);
}
void SetHideFlags()
{
PathPosition pathPosition = target as PathPosition;
//don't hide transform if there is no path yet
if (!pathPosition.Path)
{
return;
}
if (SHF != null)
{
SHF.Undo();
}
SHF = new UnityCommands.SetHideFlags(pathPosition.transform, HideFlags.NotEditable);
SHF.Execute();
}
public void AddPickup(float relativeDistance, PathPosition pathPos)
{
GameObject pickup = Instantiate <GameObject>(pickupPrefab, transform);
pickup.GetComponent <BelongToPath>().position = pathPos;
pickup.transform.localPosition = DistanceToPosition(relativeDistance) + Vector3.up * 0.5f;
Vector3 dir = DistanceToDirection(relativeDistance);
if (pathPos == PathPosition.LEFT)
{
pickup.transform.localPosition += Quaternion.Euler(0, -90, 0) * dir * rowOffset;
}
else if (pathPos == PathPosition.RIGHT)
{
pickup.transform.localPosition += Quaternion.Euler(0, 90, 0) * dir * rowOffset;
}
}
/// <summary>Parses a struct segment</summary>
/// <param name="pos">the current position in the path</param>
/// <returns>Retusn the segment or an errror</returns>
/// <exception cref="XmpException">If the sement is empty</exception>
private static XmpPathSegment ParseStructSegment(PathPosition pos)
{
pos.NameStart = pos.StepBegin;
while (pos.StepEnd < pos.Path.Length && "/[*".IndexOf(pos.Path[pos.StepEnd]) < 0)
{
pos.StepEnd++;
}
pos.NameEnd = pos.StepEnd;
if (pos.StepEnd == pos.StepBegin)
{
throw new XmpException("Empty XMPPath segment", XmpErrorCode.BadXPath);
}
// ! Touch up later, also changing '@' to '?'.
return(new XmpPathSegment(pos.Path.Substring(pos.StepBegin, pos.StepEnd - pos.StepBegin), XmpPath.StructFieldStep));
}
public void CreateEntities(int count)
{
var settings = GameObjectConversionSettings.FromWorld(World.DefaultGameObjectInjectionWorld, blobAssetStore);
var myPrefab = GameObjectConversionUtility.ConvertGameObjectHierarchy(koboltPrefab, settings);
for (int i = 0; i < count; i++)
{
var instance = entityManager.Instantiate(myPrefab);
float xValueF = UnityEngine.Random.Range(0, 10f);
float yValueF = UnityEngine.Random.Range(0f, 10f);
int xValueI = (int)Mathf.Round(xValueF) * (int)Mathf.Round(PathfindingGridSetup.Instance.pathfindingGrid.GetCellSize());
int yValueI = (int)Mathf.Round(yValueF) * (int)Mathf.Round(PathfindingGridSetup.Instance.pathfindingGrid.GetCellSize());
entityManager.SetComponentData(instance, new Translation()
{
Value = new float3(new float3(xValueF, yValueF, -0.1f))
});
entityManager.AddComponentData(instance, new IDComponent()
{
id = 1
});
entityManager.AddComponentData(instance, new HealthComponent()
{
maxHealth = 100, health = 100
});
entityManager.AddComponentData(instance, new MovementComponent()
{
isMoving = false, speed = 1.2f
});
entityManager.AddComponentData(instance, new PathFollow()
{
});
entityManager.AddComponentData(instance, new Selected()
{
isSelected = false
});
entityManager.AddBuffer <PathPosition>(instance);
PathPosition someBufferElement = new PathPosition();
DynamicBuffer <PathPosition> someBuffer = entityManager.GetBuffer <PathPosition>(instance);
someBufferElement.position = new int2(xValueI, yValueI);
someBuffer.Add(someBufferElement);
someBufferElement.position = new int2(xValueI, yValueI);
someBuffer.Add(someBufferElement);
}
}
public void AddMinionSpecificPosition(Minion minion, PathPosition position)
{
try
{
toBeAddedMinions.Add(minion);
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace + " : " + e.Message);
}
if (minion.position == null)
{
minion.position = new MinionPosition();
}
minion.position.board = this;
minion.position.pathPosition = new PathPosition(position.pointIndex, position.ratio);
}
/// <param name="path"/>
/// <param name="pos"/>
/// <exception cref="XmpException"/>
private static void SkipPathDelimiter(string path, PathPosition pos)
{
if (path[pos.StepBegin] == '/')
{
// skip slash
pos.StepBegin++;
if (pos.StepBegin >= path.Length)
throw new XmpException("Empty XMPPath segment", XmpErrorCode.BadXPath);
}
if (path[pos.StepBegin] == '*')
{
// skip asterisk
pos.StepBegin++;
if (pos.StepBegin >= path.Length || path[pos.StepBegin] != '[')
throw new XmpException("Missing '[' after '*'", XmpErrorCode.BadXPath);
}
}
/// <summary>Parses a struct segment</summary>
/// <param name="pos">the current position in the path</param>
/// <returns>Retusn the segment or an errror</returns>
/// <exception cref="XmpException">If the sement is empty</exception>
private static XmpPathSegment ParseStructSegment(PathPosition pos)
{
pos.NameStart = pos.StepBegin;
while (pos.StepEnd < pos.Path.Length && "/[*".IndexOf(pos.Path[pos.StepEnd]) < 0)
pos.StepEnd++;
pos.NameEnd = pos.StepEnd;
if (pos.StepEnd == pos.StepBegin)
throw new XmpException("Empty XMPPath segment", XmpErrorCode.BadXPath);
// ! Touch up later, also changing '@' to '?'.
return new XmpPathSegment(pos.Path.Substring (pos.StepBegin, pos.StepEnd - pos.StepBegin), XmpPath.StructFieldStep);
}
/// <summary>Parses an array index segment.</summary>
/// <param name="pos">the xmp path</param>
/// <returns>Returns the segment or an error</returns>
/// <exception cref="XmpException">thrown on xmp path errors</exception>
private static XmpPathSegment ParseIndexSegment(PathPosition pos)
{
XmpPathSegment segment;
pos.StepEnd++;
// Look at the character after the leading '['.
if ('0' <= pos.Path[pos.StepEnd] && pos.Path[pos.StepEnd] <= '9')
{
// A numeric (decimal integer) array index.
while (pos.StepEnd < pos.Path.Length && '0' <= pos.Path[pos.StepEnd] && pos.Path[pos.StepEnd] <= '9')
pos.StepEnd++;
segment = new XmpPathSegment(null, XmpPath.ArrayIndexStep);
}
else
{
// Could be "[last()]" or one of the selector forms. Find the ']' or '='.
while (pos.StepEnd < pos.Path.Length && pos.Path[pos.StepEnd] != ']' && pos.Path[pos.StepEnd] != '=')
pos.StepEnd++;
if (pos.StepEnd >= pos.Path.Length)
throw new XmpException("Missing ']' or '=' for array index", XmpErrorCode.BadXPath);
if (pos.Path[pos.StepEnd] == ']')
{
if (!"[last()".Equals(pos.Path.Substring(pos.StepBegin, pos.StepEnd - pos.StepBegin)))
throw new XmpException("Invalid non-numeric array index", XmpErrorCode.BadXPath);
segment = new XmpPathSegment(null, XmpPath.ArrayLastStep);
}
else
{
pos.NameStart = pos.StepBegin + 1;
pos.NameEnd = pos.StepEnd;
pos.StepEnd++;
// Absorb the '=', remember the quote.
var quote = pos.Path[pos.StepEnd];
if (quote != '\'' && quote != '"')
throw new XmpException("Invalid quote in array selector", XmpErrorCode.BadXPath);
pos.StepEnd++;
// Absorb the leading quote.
while (pos.StepEnd < pos.Path.Length)
{
if (pos.Path[pos.StepEnd] == quote)
{
// check for escaped quote
if (pos.StepEnd + 1 >= pos.Path.Length || pos.Path[pos.StepEnd + 1] != quote)
break;
pos.StepEnd++;
}
pos.StepEnd++;
}
if (pos.StepEnd >= pos.Path.Length)
throw new XmpException("No terminating quote for array selector", XmpErrorCode.BadXPath);
pos.StepEnd++;
// Absorb the trailing quote.
// ! Touch up later, also changing '@' to '?'.
segment = new XmpPathSegment(null, XmpPath.FieldSelectorStep);
}
}
if (pos.StepEnd >= pos.Path.Length || pos.Path[pos.StepEnd] != ']')
throw new XmpException("Missing ']' for array index", XmpErrorCode.BadXPath);
pos.StepEnd++;
segment.Name = pos.Path.Substring (pos.StepBegin, pos.StepEnd - pos.StepBegin);
return segment;
}
/// <summary>
/// Parses the root node of an XMP Path, checks if namespace and prefix fit together
/// and resolve the property to the base property if it is an alias.
/// </summary>
/// <param name="schemaNs">the root namespace</param>
/// <param name="pos">the parsing position helper</param>
/// <param name="expandedXPath">the path to contribute to</param>
/// <exception cref="XmpException">If the path is not valid.</exception>
private static void ParseRootNode(string schemaNs, PathPosition pos, XmpPath expandedXPath)
{
while (pos.StepEnd < pos.Path.Length && "/[*".IndexOf(pos.Path[pos.StepEnd]) < 0)
pos.StepEnd++;
if (pos.StepEnd == pos.StepBegin)
throw new XmpException("Empty initial XMPPath step", XmpErrorCode.BadXPath);
var rootProp = VerifyXPathRoot(schemaNs, pos.Path.Substring (pos.StepBegin, pos.StepEnd - pos.StepBegin));
var aliasInfo = XmpMetaFactory.SchemaRegistry.FindAlias(rootProp);
if (aliasInfo == null)
{
// add schema xpath step
expandedXPath.Add(new XmpPathSegment(schemaNs, XmpPath.SchemaNode));
var rootStep = new XmpPathSegment(rootProp, XmpPath.StructFieldStep);
expandedXPath.Add(rootStep);
}
else
{
// add schema xpath step and base step of alias
expandedXPath.Add(new XmpPathSegment(aliasInfo.Namespace, XmpPath.SchemaNode));
var rootStep = new XmpPathSegment(VerifyXPathRoot(aliasInfo.Namespace, aliasInfo.PropName), XmpPath.StructFieldStep);
rootStep.IsAlias = true;
rootStep.AliasForm = aliasInfo.AliasForm.GetOptions();
expandedXPath.Add(rootStep);
if (aliasInfo.AliasForm.IsArrayAltText)
{
var qualSelectorStep = new XmpPathSegment("[?xml:lang='x-default']", XmpPath.QualSelectorStep);
qualSelectorStep.IsAlias = true;
qualSelectorStep.AliasForm = aliasInfo.AliasForm.GetOptions();
expandedXPath.Add(qualSelectorStep);
}
else if (aliasInfo.AliasForm.IsArray)
{
var indexStep = new XmpPathSegment("[1]", XmpPath.ArrayIndexStep);
indexStep.IsAlias = true;
indexStep.AliasForm = aliasInfo.AliasForm.GetOptions();
expandedXPath.Add(indexStep);
}
}
}
/// <summary>
/// Split an XMPPath expression apart at the conceptual steps, adding the
/// root namespace prefix to the first property component.
/// </summary>
/// <remarks>
/// The schema URI is put in the first (0th) slot in the expanded XMPPath.
/// Check if the top level component is an alias, but don't resolve it.
/// <para />
/// In the most verbose case steps are separated by '/', and each step can be
/// of these forms:
/// <list>
/// <item>
/// <term>prefix:name</term>
/// <description>A top level property or struct field.</description>
/// </item>
/// <item>
/// <term>[index]</term>
/// <description>An element of an array.</description>
/// </item>
/// <item>
/// <term>[last()]</term>
/// <description>The last element of an array.</description>
/// </item>
/// <item>
/// <term>[fieldName="value"]</term>
/// <description>An element in an array of structs, chosen by a field value.</description>
/// </item>
/// <item>
/// <term>[@xml:lang="value"]</term>
/// <description>An element in an alt-text array, chosen by the xml:lang qualifier.</description>
/// </item>
/// <item>
/// <term>[?qualName="value"]</term>
/// <description>An element in an array, chosen by a qualifier value.</description>
/// </item>
/// <item>
/// <term>@xml:lang</term>
/// <description>An xml:lang qualifier.</description>
/// </item>
/// <item>
/// <term>?qualName</term>
/// <description>A general qualifier.</description>
/// </item>
/// </list>
/// <para />
/// The logic is complicated though by shorthand for arrays, the separating
/// '/' and leading '*' are optional. These are all equivalent: array/*[2]
/// array/[2] array*[2] array[2] All of these are broken into the 2 steps
/// "array" and "[2]".
/// <para />
/// The value portion in the array selector forms is a string quoted by '''
/// or '"'. The value may contain any character including a doubled quoting
/// character. The value may be empty.
/// <para />
/// The syntax isn't checked, but an XML name begins with a letter or '_',
/// and contains letters, digits, '.', '-', '_', and a bunch of special
/// non-ASCII Unicode characters. An XML qualified name is a pair of names
/// separated by a colon.
/// </remarks>
/// <param name="schemaNs">schema namespace</param>
/// <param name="path">property name</param>
/// <returns>Returns the expandet XMPPath.</returns>
/// <exception cref="XmpException">Thrown if the format is not correct somehow.</exception>
public static XmpPath ExpandXPath(string schemaNs, string path)
{
if (schemaNs == null || path == null)
throw new XmpException("Parameter must not be null", XmpErrorCode.BadParam);
var expandedXPath = new XmpPath();
var pos = new PathPosition { Path = path };
// Pull out the first component and do some special processing on it: add the schema
// namespace prefix and and see if it is an alias. The start must be a "qualName".
ParseRootNode(schemaNs, pos, expandedXPath);
// Now continue to process the rest of the XMPPath string.
while (pos.StepEnd < path.Length)
{
pos.StepBegin = pos.StepEnd;
SkipPathDelimiter(path, pos);
pos.StepEnd = pos.StepBegin;
var segment = path[pos.StepBegin] != '['
? ParseStructSegment(pos)
: ParseIndexSegment(pos);
if (segment.Kind == XmpPath.StructFieldStep)
{
if (segment.Name[0] == '@')
{
segment.Name = "?" + segment.Name.Substring (1);
if (!"?xml:lang".Equals(segment.Name))
throw new XmpException("Only xml:lang allowed with '@'", XmpErrorCode.BadXPath);
}
if (segment.Name[0] == '?')
{
pos.NameStart++;
segment.Kind = XmpPath.QualifierStep;
}
VerifyQualName(pos.Path.Substring (pos.NameStart, pos.NameEnd - pos.NameStart));
}
else if (segment.Kind == XmpPath.FieldSelectorStep)
{
if (segment.Name[1] == '@')
{
segment.Name = "[?" + segment.Name.Substring (2);
if (!segment.Name.StartsWith("[?xml:lang="))
throw new XmpException("Only xml:lang allowed with '@'", XmpErrorCode.BadXPath);
}
if (segment.Name[1] == '?')
{
pos.NameStart++;
segment.Kind = XmpPath.QualSelectorStep;
VerifyQualName(pos.Path.Substring (pos.NameStart, pos.NameEnd - pos.NameStart));
}
}
expandedXPath.Add(segment);
}
return expandedXPath;
}
