private static void ParseTracks(GpxFile xml, GpsData data)
{
if (xml.trk != null)
{
foreach (var trkType in xml.trk)
{
var track = new Track();
track.Metadata.Attribute(x => x.Name, trkType.name);
track.Metadata.Attribute(x => x.Description, trkType.desc);
track.Metadata.Attribute(x => x.Comment, trkType.cmt);
foreach (var trksegTrkpt in trkType.trkseg.Where(seg => seg.trkpt != null))
{
var segment = new TrackSegment();
foreach (var wptType in trksegTrkpt.trkpt)
{
segment.Waypoints.Add(ConvertWaypoint(wptType));
}
track.Segments.Add(segment);
}
data.Tracks.Add(track);
}
}
}
public override void Spawn(TrackSegment segment, float t)
{
//the tutorial very firts barricade need to be center and alone, so player can swipe safely in bother direction to avoid it
bool isTutorialFirst = TrackManager.instance.isTutorial && TrackManager.instance.segments.Count == 0;
int count = isTutorialFirst ? 1 : Random.Range(k_MinObstacleCount, k_MaxObstacleCount + 1);
int startLane = isTutorialFirst ? 0 : Random.Range(k_LeftMostLaneIndex, k_RightMostLaneIndex + 1);
Vector3 position;
Quaternion rotation;
segment.GetPointAt(t, out position, out rotation);
for (int i = 0; i < count; ++i)
{
int lane = startLane + i;
lane = lane > k_RightMostLaneIndex ? k_LeftMostLaneIndex : lane;
GameObject obj = Instantiate(gameObject, position, rotation);
obj.transform.position += obj.transform.right * lane * segment.manager.laneOffset;
obj.transform.SetParent(segment.objectRoot, true);
//TODO : remove that hack related to #issue7
Vector3 oldPos = obj.transform.position;
obj.transform.position += Vector3.back;
obj.transform.position = oldPos;
}
}
public void SpawnObstacle(TrackSegment segment)
{
if (segment.possibleObstacles.Length != 0)
{
for (int i = 0; i < segment.obstaclePositions.Length; ++i)
{
Obstacle newObstacle = segment.possibleObstacles[Random.Range(0, segment.possibleObstacles.Length)];
if (!AICharacterController.isVerticalMovementEnabled)
{
// TODO fix pls
while (newObstacle is AllLaneObstacle)
{
newObstacle = segment.possibleObstacles[Random.Range(0, segment.possibleObstacles.Length)];
}
}
if (newObstacle is Missile ||
newObstacle is PatrollingObstacle)
{
return;
}
newObstacle.Spawn(segment, segment.obstaclePositions[i]);
}
}
SpawnCoinAndPowerup(segment);
}
private bool ParseFix(string line, TrackSegment trackSegment, DateTime date)
{
if (string.IsNullOrWhiteSpace(line))
{
return(false);
}
var match = Regex.Match(line, B_LINE_REGEX);
if (match.Success)
{
string h = match.Groups["h"].Value;
string m = match.Groups["m"].Value;
string s = match.Groups["s"].Value;
string coord = match.Groups["coord"].Value;
string validAlt = match.Groups["validAlt"].Value;
string presAlt = match.Groups["presAlt"].Value;
string gpsAlt = match.Groups["gpsAlt"].Value;
var cood = ParseCoordinate(coord);
var fix = new Fix(cood.Latitude, cood.Longitude, double.Parse(gpsAlt), date.AddHours(int.Parse(h)).AddMinutes(int.Parse(m)).AddSeconds(int.Parse(s)));
trackSegment.Fixes.Add(fix);
return(true);
}
return(false);
}
private bool ParseFix(string line, TrackSegment trackSegment)
{
if (string.IsNullOrWhiteSpace(line))
{
return(false);
}
var match = Regex.Match(line, FIX_SENTENCE);
if (match.Success)
{
int h = int.Parse(match.Groups["h"].Value, CultureInfo.InvariantCulture);
int m = int.Parse(match.Groups["m"].Value, CultureInfo.InvariantCulture);
double s = double.Parse(match.Groups["s"].Value, CultureInfo.InvariantCulture);
double alt = double.Parse(match.Groups["alt"].Value, CultureInfo.InvariantCulture);
double lat = ConvertOrd(match.Groups["lat"].Value, match.Groups["latd"].Value);
double lon = ConvertOrd(match.Groups["lon"].Value, match.Groups["lond"].Value);
var waypoint = new Waypoint(lat, lon, alt, DateTime.MinValue.AddHours(h).AddMinutes(m).AddSeconds(s));
trackSegment.Waypoints.Add(waypoint);
return(true);
}
return(false);
}
private bool ParseFix(string line, TrackSegment trackSegment)
{
if (line.IsNullOrWhitespace())
{
return(false);
}
var match = Regex.Match(line, FIX_SENTENCE);
if (match.Success)
{
int h = int.Parse(match.Groups["h"].Value);
int m = int.Parse(match.Groups["m"].Value);
double s = double.Parse(match.Groups["s"].Value);
double alt = double.Parse(match.Groups["alt"].Value);
double lat = ConvertOrd(match.Groups["lat"].Value, match.Groups["latd"].Value);
double lon = ConvertOrd(match.Groups["lon"].Value, match.Groups["lond"].Value);
var fix = new Fix(lat, lon, alt, DateTime.MinValue.AddHours(h).AddMinutes(m).AddSeconds(s));
trackSegment.Fixes.Add(fix);
return(true);
}
return(false);
}
public GpsData DeSerialize(StreamWrapper streamWrapper)
{
var data = new GpsData();
var trackSegment = new TrackSegment();
streamWrapper.Position = 0;
using (var reader = new StreamReader(streamWrapper))
{
string line;
while ((line = reader.ReadLine()) != null)
{
if (ParseFix(line, trackSegment))
{
continue;
}
if (ParseWaypoint(line, data))
{
continue;
}
}
}
if (!trackSegment.IsEmpty())
{
data.Tracks.Add(new Track());
data.Tracks[0].Segments.Add(trackSegment);
}
return(data);
}
public void StartGame()
{
canvas.gameObject.SetActive(true);
pauseMenu.gameObject.SetActive(false);
wholeUI.gameObject.SetActive(true);
pauseButton.gameObject.SetActive(!trackManager.isTutorial);
gameOverPopup.SetActive(false);
sideSlideTuto.SetActive(false);
upSlideTuto.SetActive(false);
downSlideTuto.SetActive(false);
finishTuto.SetActive(false);
tutorialValidatedObstacles.gameObject.SetActive(false);
if (!trackManager.isRerun)
{
m_TimeSinceStart = 0;
trackManager.characterController.currentLife = trackManager.characterController.maxLife;
}
currentModifier.OnRunStart(this);
m_IsTutorial = !PlayerData.instance.tutorialDone;
trackManager.isTutorial = m_IsTutorial;
if (m_IsTutorial)
{
tutorialValidatedObstacles.gameObject.SetActive(true);
tutorialValidatedObstacles.text = $"0/{k_ObstacleToClear}";
m_DisplayTutorial = true;
trackManager.newSegmentCreated = segment =>
{
if (trackManager.currentZone != 0 && !m_CountObstacles && m_NextValidSegment == null)
{
m_NextValidSegment = segment;
}
};
trackManager.currentSegementChanged = segment =>
{
m_CurrentSegmentObstacleIndex = 0;
if (!m_CountObstacles && trackManager.currentSegment == m_NextValidSegment)
{
trackManager.characterController.currentTutorialLevel += 1;
m_CountObstacles = true;
m_NextValidSegment = null;
m_DisplayTutorial = true;
tutorialValidatedObstacles.text = $"{m_TutorialClearedObstacle}/{k_ObstacleToClear}";
}
};
}
m_Finished = false;
m_PowerupIcons.Clear();
StartCoroutine(trackManager.Begin());
}
public static Track ReadFromTrackElement(System.Xml.XmlElement TrackElement)
{
var Result = new Track();
foreach (System.Xml.XmlNode TrackChildNode in TrackElement.ChildNodes)
{
if ((TrackChildNode.NodeType == System.Xml.XmlNodeType.Element) && (TrackChildNode.Name == "description"))
{
Result._Description = TrackChildNode.FirstChild.InnerText;
}
else if ((TrackChildNode.NodeType == System.Xml.XmlNodeType.Element) && (TrackChildNode.Name == "name"))
{
Result._Name = TrackChildNode.FirstChild.InnerText;
}
else if ((TrackChildNode.NodeType == System.Xml.XmlNodeType.Element) && (TrackChildNode.Name == "trkseg"))
{
var TrackSegment = new TrackSegment();
foreach (System.Xml.XmlNode TrackSegmentChildNode in TrackChildNode)
{
if ((TrackSegmentChildNode.NodeType == System.Xml.XmlNodeType.Element) && (TrackSegmentChildNode.Name == "trkpt"))
{
TrackSegment.TrackPoints.Add(TrackPoint.LoadFromTrackPointElement((System.Xml.XmlElement)TrackSegmentChildNode));
}
}
Result._TrackSegments.Add(TrackSegment);
}
}
return(Result);
}
private static void ParseTracks(GpxFile xml, GpsData data)
{
if (xml.trk != null)
{
foreach (var trkType in xml.trk)
{
var track = new Track();
track.Metadata.Attribute(x => x.Name, trkType.name);
track.Metadata.Attribute(x => x.Description, trkType.desc);
track.Metadata.Attribute(x => x.Comment, trkType.cmt);
foreach (var trksegType in trkType.trkseg)
{
var segment = new TrackSegment();
foreach (var wptType in trksegType.trkpt)
{
var fix = new Fix((double)wptType.lat, (double)wptType.lon, (double)wptType.ele, wptType.time);
segment.Fixes.Add(fix);
}
track.Segments.Add(segment);
}
data.Tracks.Add(track);
}
}
}
/// <summary>
/// Called by Unity engine when the player finish dragging mouse
/// </summary>
void IEndDragHandler.OnEndDrag(PointerEventData eventData)
{
switch (eventData.button)
{
// If Left mouse button, add last point and validate
case PointerEventData.InputButton.Left:
{
// Determine active Track Segment
TrackSegment currentTrack = _track.Last();
// Add current point
currentTrack.AddPoint(eventData.position.ScreenToWorld());
// If new Track doesn't have enough points, remove it
if (!currentTrack.IsValid)
{
_track.Remove(currentTrack);
Destroy(currentTrack.gameObject);
}
break;
}
// If right button is pressed, switch back to default mouse cursor
case PointerEventData.InputButton.Right:
{
Cursor.SetCursor(DrawingCursor, new Vector2(0, 64), CursorMode.ForceSoftware);
break;
}
}
}
public void AddSegments(TrackNode node)
{
List <KeyValuePair <int, int> > listTrItems = distributeTrItem(node);
TrVectorSection[] items = node.TrVectorNode.TrVectorSections;
for (int idx = 0; idx < items.Length - 1; idx++)
{
//Program.actEditor.DisplayStatusMessage("Init data for display... Load Vector Nodes: " + node.Index + "." + idx);
TrVectorSection item1 = node.TrVectorNode.TrVectorSections[idx];
TrVectorSection item2 = node.TrVectorNode.TrVectorSections[idx + 1];
AESegment aeSegment = new AESegment(item1, item2);
TrackSegment lineSeg = new TrackSegment(aeSegment, node, idx, item1.Flag2, TSectionDat);
var values = listTrItems.GroupBy(x => x.Key == idx);
foreach (var idxTrItem in values)
{
if (!idxTrItem.Key)
{
break;
}
foreach (var val in idxTrItem)
{
var item = TDB.TrackDB.TrItemTable[val.Value];
addTrItem(lineSeg, item);
}
}
//Program.actEditor.DisplayStatusMessage("Init data for display... Load Vector Nodes: " + node.Index + "." + idx + ".");
mstsItems.AddSegment(lineSeg);
//lineSeg = new TrackSegment(node, i, TSectionDat);
areaRoute.manageTiles(item1.TileX, item1.TileZ);
}
areaRoute.manageTiles(items[items.Length - 1].TileX, items[items.Length - 1].TileZ);
}
public void addTrItem(TrackSegment tr)
{
if (tr != null)
{
trItems.Add(tr);
}
}
public override IEnumerator Spawn(TrackSegment segment, float t)
{
Vector3 position;
Quaternion rotation;
segment.GetPointAt(t, out position, out rotation);
AsyncOperationHandle op = Addressables.InstantiateAsync(gameObject.name, position, rotation);
yield return(op);
if (op.Result == null || !(op.Result is GameObject))
{
Debug.LogWarning(string.Format("Unable to load obstacle {0}.", gameObject.name));
yield break;
}
GameObject obj = op.Result as GameObject;
obj.transform.SetParent(segment.objectRoot, true);
//TODO : remove that hack related to #issue7
Vector3 oldPos = obj.transform.position;
obj.transform.position += Vector3.back;
obj.transform.position = oldPos;
}
void Remove()
{
//Destroy the last piece on the stack and revert to the values before that
if (pieceHistory.Count > 0)
{
TrackSegment lastPiece = pieceHistory.Pop();
Destroy(lastPiece.gameObject);
checkpointCounter -= segmentCount;
if (pieceHistory.Count > 0)
{
lastPiece = pieceHistory.Peek();
lastPiece.GetData(out x, out y, out ax, out bx, out cx, out ay, out by, out cy);
return;
}
}
//Stack is empty, use default values
x = 0;
y = 0;
ax = 10;
bx = 0;
cx = -10;
ay = 0;
by = 0;
cy = 0;
}
public TrackSegmentInterface(TrackSegment trackSegment, List <string> givenDestination)
{
List <string> destination = givenDestination;
segment = trackSegment;
InitializeComponent();
}
void OnSceneGUI()
{
// Creeation des ID
int arrowIDForward = GUIUtility.GetControlID("Arrow Forward".GetHashCode(), FocusType.Passive);
int arrowIDBack = GUIUtility.GetControlID("Arrow Back".GetHashCode(), FocusType.Passive);
// Recupere les variables utiles
TrackSegment track = target as TrackSegment;
Vector3 origin = track.GetControlPoint(0, Space.World);
Vector3 tangentForward = track.GetControlPoint(1, Space.World);
Vector3 tangentBack = origin * 2 - tangentForward;
Vector3 tangentDir = track.transform.forward;
// Creation du plane
Vector3 camUp = SceneView.lastActiveSceneView.camera.transform.up;
Vector3 pNormal = Vector3.Cross(tangentDir, camUp).normalized;
Plane draggingPlane = new Plane(pNormal, origin);
float newDistance = 0;
// Affichage des handles pour la tangente
bool changedForward = DrawTangentHandle(arrowIDForward, tangentForward, origin, tangentDir, draggingPlane, ref newDistance);
bool changedBack = DrawTangentHandle(arrowIDBack, tangentBack, origin, -tangentDir, draggingPlane, ref newDistance);
// Si un des handle est modifie on met a jour la distance
if (changedForward || changedBack)
{
Undo.RecordObject(target, "adjust bezier tangent");
track.tangentLength = newDistance;
track.RoadChain?.UpdateSegments();
}
}
public static void DeSpawnObstacles(ref TrackSegment despawnSegment)
{
for (int i = 0; i < despawnSegment.possibleObstacles.Length; i++)
{
despawnSegment.possibleObstacles[i].gameObject.SetActive(false);
}
}
/// <summary>
/// Recupere un des 4 point de control de la courbe de bezier
/// </summary>
/// <param name="i"></param>
/// <param name="space"></param>
/// <returns></returns>
public Vector3 GetControlPoint(int i, Space space)
{
if (i < 2)
{
if (0 == i)
{
return((space == Space.Self) ? Vector3.zero : transform.TransformPoint(Vector3.zero));
}
if (1 == i)
{
return((space == Space.Self) ? Vector3.forward * tangentLength : transform.TransformPoint(Vector3.forward * tangentLength));
}
}
else
{
TrackSegment next = TryGetNextSegment();
Transform nextTf = next.transform;
if (2 == i)
{
return((space == Space.World) ? nextTf.TransformPoint(Vector3.back * next.tangentLength) : transform.InverseTransformPoint(nextTf.TransformPoint(Vector3.back * next.tangentLength)));
}
if (3 == i)
{
return((space == Space.World) ? nextTf.position : transform.InverseTransformPoint(nextTf.position));
}
}
return(default);
public void ReadGpxData(GpxFile gpxFile, Stream stream)
{
XmlSerializer serializer = new XmlSerializer (typeof (gpx));
gpx gpx = (gpx)serializer.Deserialize (stream);
if (gpx.trk != null)
{
foreach (gpxTrk trkType in gpx.trk)
{
Track track = new Track ();
foreach (gpxTrkTrkseg trkseg in trkType.trkseg)
{
if (trkseg.trkpt.Length > 0)
{
TrackSegment segment = new TrackSegment ();
foreach (gpxTrkTrksegTrkpt trkpt in trkseg.trkpt)
{
TrackPoint waypoint = ReadTrackPoint (trkpt);
segment.AddPoint (waypoint);
}
track.AddSegment (segment);
}
}
gpxFile.AddTrack (track);
}
}
if (gpx.wpt != null)
{
foreach (gpxWpt wptType in gpx.wpt)
{
TrackPoint waypoint = ReadWayoint(wptType);
gpxFile.AddWaypoint (waypoint);
}
}
if (gpx.rte != null)
{
foreach (gpxRte rteType in gpx.rte)
{
Track route = new Track ();
if (rteType.rtept != null)
{
TrackSegment segment = new TrackSegment ();
foreach (gpxRteRtept wptType in rteType.rtept)
{
TrackPoint waypoint = ReadRoutePoint (wptType);
segment.AddPoint (waypoint);
}
}
gpxFile.AddRoute (route);
}
}
}
public override void Spawn(TrackSegment segment, bool toChange)
{
GameObject obj = Instantiate(gameObject,
new Vector3(-transform.position.x, transform.position.y, transform.position.z),
new Quaternion(transform.rotation.x, transform.rotation.y + 180, transform.rotation.z, transform.rotation.w));
obj.transform.SetParent(segment.objectRoot, true);
}
public void CanSetMultiplePointsToATrackSegment()
{
var sut = new TrackSegment();
sut.TrackPoints = new[] { new TrackPoint(), new TrackPoint() };
Assert.That(sut.TrackPoints.Count(), Is.EqualTo(2));
}
/*--------------------------------------------------------------------------------------------*/
public static TrackSegment[] SplitTrackSegments(TrackSegment[] pSegments, TrackSegment[] pCuts)
{
var slices = pSegments.ToList();
foreach (TrackSegment cut in pCuts)
{
for (int i = 0; i < slices.Count; i++)
{
TrackSegment slice = slices[i];
if (cut.StartValue >= slice.StartValue && cut.EndValue <= slice.EndValue)
{
var slice2 = new TrackSegment();
slice2.StartValue = cut.EndValue;
slice2.EndValue = slice.EndValue;
slice2.IsFill = slice.IsFill;
slices.Insert(i + 1, slice2);
slice.EndValue = cut.StartValue;
slices[i] = slice;
continue;
}
if (cut.StartValue >= slice.StartValue && cut.StartValue <= slice.EndValue)
{
slice.EndValue = cut.StartValue;
slices[i] = slice;
continue;
}
if (cut.EndValue <= slice.EndValue && cut.EndValue >= slice.StartValue)
{
slice.StartValue = cut.EndValue;
slices[i] = slice;
continue;
}
if (cut.StartValue <= slice.StartValue && cut.EndValue >= slice.EndValue)
{
slices.RemoveAt(i);
i--;
}
}
}
for (int i = 0; i < slices.Count; i++)
{
TrackSegment slice = slices[i];
if (Math.Abs(slice.StartValue - slice.EndValue) <= 0.01f)
{
slices.RemoveAt(i);
i--;
}
}
return(slices.ToArray());
}
// Start is called before the first frame update
private void Start()
{
// Заполняем опорное точки
corners = new Vector3[this.transform.childCount];
for (var i = 0; i < corners.Length; i++)
{
GameObject obj = transform.GetChild(i).gameObject;
corners[i] = obj.transform.position;
//отключение отрисовки объекта/
obj.GetComponent <MeshRenderer>().enabled = false;
}
//настраиваем Line Renderer
m_lineRenderer.positionCount = corners.Length;
m_lineRenderer.SetPositions(corners);
//сгенерировать всех соседей в одном сегменте
//проверять только массив соседей
//запекаем меш сетку из Line Renderer
Mesh mesh = new Mesh();
m_lineRenderer.BakeMesh(mesh, true);
//создаем массив сегментов трассы
//(каждый треугольник описан 3-мя точками из массива вершин)
segments = new TrackSegment[mesh.triangles.Length / 3];
//каждую итерацию цикла проходим через каждый треий элемент
for (int i = 0; i < mesh.triangles.Length; i += 3)
{
segments[segmentCounter] = new TrackSegment();
segments[segmentCounter].Points = new Vector3[3];
//в первую точку записываем вершину первого индекса из массива вершин
segments[segmentCounter].Points[0] = mesh.vertices[mesh.triangles[i]];
segments[segmentCounter].Points[1] = mesh.vertices[mesh.triangles[i + 1]];
segments[segmentCounter].Points[2] = mesh.vertices[mesh.triangles[i + 2]];
segmentCounter++;
}
//отдельно можно продебажить сегменты
if (!m_Debug)
{
return;
}
foreach (var segment in segments)
{
foreach (var point in segment.Points)
{
GameObject sphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
sphere.transform.position = point;
sphere.transform.localScale = Vector3.one * 0.1f;
}
}
}
public static void AssertAreEqual(TrackSegment recData, GPBikes.SPluginsTrackSegment_t data)
{
Assert.AreEqual(recData.Type, data.Type);
Assert.AreEqual(recData.Length, data.Length);
Assert.AreEqual(recData.Radius, data.Radius);
Assert.AreEqual(recData.Angle, data.Angle);
Assert.AreEqual(recData.Start1, data.Start[0]);
Assert.AreEqual(recData.Start2, data.Start[1]);
}
public void CreateCheckpoint(TrackSegment Segment, GameObject CheckpointPref)
{
Array.Resize(ref ChPoints, ChPoints.Length + 1);
ChPoints[0] = Segment.Points[0];
ChPoints[1] = Segment.Points[1];
ChPoints[2] = Segment.Points[2];
//GameObject chp = Instantiate(CheckpointPref);
//chp.transform.position = new Vector3(ChPoints[0].x, ChPoints[1].y, 0);
}
public override void Spawn(TrackSegment segment, float t, int l)
{
Vector3 position;
Quaternion rotation;
segment.GetPointAt(t, out position, out rotation);
GameObject obj = Instantiate(gameObject, position, rotation);
obj.transform.SetParent(segment.objectRoot, true);
}
static void Main(string[] args)
{
Parser.Default.ParseArguments <Options>(args)
.WithParsed(o =>
{
Console.WriteLine($"Reading source {o.Source}");
using StreamReader sw = new StreamReader(o.Source);
using JsonReader reader = new JsonTextReader(sw);
var serializer = new JsonSerializer();
var json = serializer.Deserialize <GoogleLocationExport>(reader);
Func <GooglePartialConvert, string> groupBy = o.SplitBy switch
{
Options.Split.None => (GooglePartialConvert data) => "",
Options.Split.Year => (GooglePartialConvert data) => data.Time.Year.ToString(),
Options.Split.Month => (GooglePartialConvert data) => $"{data.Time.Year}-{data.Time.Month}",
_ => throw new NotImplementedException(),
};
Console.WriteLine($"Parsing source {o.Source}");
var groups = json.locations.Select(x => new GooglePartialConvert
{
Time = DateTimeOffset.FromUnixTimeMilliseconds(long.Parse(x.timestampMs)).DateTime,
Data = x
}).GroupBy(groupBy);
foreach (var group in groups)
{
var track = new Track();
var trackSegment = new TrackSegment();
foreach (var data in group)
{
var location = data.Data;
trackSegment.Waypoints.Add(new Waypoint(location.latitudeE7 / 1e7, location.longitudeE7 / 1e7, location.altitude, data.Time));
}
track.Segments.Add(trackSegment);
var gpsData = new GpsData();
gpsData.Tracks.Add(track);
Console.WriteLine($"Found {trackSegment.Waypoints.Count} waypoints");
var output = Path.Combine(Path.GetDirectoryName(o.Output), $"{Path.GetFileName(o.Output)}_{group.Key}.gpx");
Console.WriteLine($"Writting output {output}");
var gpx11Serializer = new Geo.Gps.Serialization.Gpx11Serializer();
using var writeStream = File.OpenWrite(output);
gpx11Serializer.Serialize(gpsData, writeStream);
}
});
}
// Start is called before the first frame update
void Start()
{
//заполняем массив опорных точек трассы
corners = new Vector3[transform.childCount];
for (int i = 0; i < corners.Length; i++)
{
GameObject obj = transform.GetChild(i).gameObject;
corners[i] = obj.transform.position;
obj.GetComponent <MeshRenderer>().enabled = false;
}
//задаём значения linerenderer
m_lineRenderer.positionCount = corners.Length;
m_lineRenderer.SetPositions(corners);
//из полученного LineRenderer запекаем mesh
Mesh mesh = new Mesh();
m_lineRenderer.BakeMesh(mesh, true);
//создаём массив сегментов трассы
//каждый треугольник уписываем треугольниками из массива вершин
segments = new TrackSegment[mesh.triangles.Length / 3];
int segmentsCounter = 0;
for (int i = 0; i < mesh.triangles.Length; i += 3)
{
segments[segmentsCounter] = new TrackSegment();
segments[segmentsCounter].points = new Vector3[3];
int nm = mesh.triangles[i];
segments[segmentsCounter].points[0] = mesh.vertices[nm];
nm = mesh.triangles[i + 1];
segments[segmentsCounter].points[1] = mesh.vertices[nm];
nm = mesh.triangles[i + 2];
segments[segmentsCounter].points[2] = mesh.vertices[nm];
segmentsCounter++;
}
if (!m_viewDebug)
{
return;
}
else
{
foreach (var segment in segments)
{
foreach (var point in segment.points)
{
GameObject sphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
sphere.transform.position = point;
sphere.transform.localScale = Vector3.one * 0.1f;
}
}
}
}
public void SetupVehicle(ObjectPool _vehiclePool, bool _isFirstVehicle)
{
gameObjectType = GameObjectType.Vehicle;
vehiclePool = _vehiclePool;
levelConfig = TrackManager.Instance.levelConfig;
// set track
int randomTrack = UnityEngine.Random.Range(0, 3);
Vector3 randomTrackPosition = Vector3.zero;
if (randomTrack == 0)
{
randomTrackPosition.x = -TrackManager.Instance.laneOffset;
}
if (randomTrack == 2)
{
randomTrackPosition.x = TrackManager.Instance.laneOffset;
}
speed = UnityEngine.Random.Range(levelConfig.vehicleSpeedMin, levelConfig.vehicleSpeedMax);
if (TrackManager.Instance.characterControlScript != null)
{
TrackSegment trackSegment = TrackManager.Instance.FindCurrentSegmentAt(TrackManager.Instance.characterControlScript.transform.position);
if (trackSegment != null)
{
int random = UnityEngine.Random.Range(0, 2);
bool fromFront = Convert.ToBoolean(random);
int segmentIndex = trackSegment.segmentIndex - 1;
speed = UnityEngine.Random.Range(levelConfig.vehicleSpeedMax * 0.5f, levelConfig.vehicleSpeedMax);
if (fromFront)
{
segmentIndex = trackSegment.segmentIndex + 5;
speed = UnityEngine.Random.Range(levelConfig.vehicleSpeedMin, levelConfig.vehicleSpeedMax * 0.5f);
}
trackSegment = TrackManager.Instance.GetSegmentWithSegmentIndex(segmentIndex);
randomTrackPosition.z = trackSegment.startPoint.position.z;
}
if (_isFirstVehicle)
{
randomTrackPosition = new Vector3(TrackManager.Instance.characterControlScript.characterColliderScript.transform.position.x,
TrackManager.Instance.characterControlScript.transform.position.y,
TrackManager.Instance.characterControlScript.transform.position.z);
}
}
else
{
// very first time. character will be created after vehicle.
randomTrackPosition = Vector3.zero;
}
transform.position = randomTrackPosition;
}
/// <summary>
/// Called by Unity engine when the player start mouse drag
/// </summary>
void IBeginDragHandler.OnBeginDrag(PointerEventData eventData)
{
switch (eventData.button)
{
// If Left mouse button, start a new Track Segment
case PointerEventData.InputButton.Left:
{
// Convert position from Screen Coordinates into World ones
Vector2 position = eventData.pressPosition.ScreenToWorld();
// Check whether to snap to a previous point
if (_track.Count > 0)
{
for (int ti = _track.Count - 1; ti >= 0; ti--)
{
TrackSegment currentTrack = _track[ti];
for (int pi = currentTrack.PointCount - 1; pi >= 0; pi--)
{
if ((currentTrack[pi] - position).magnitude < SnapRange)
{
position = currentTrack[pi];
break;
}
}
}
}
// Create a new Game Object for the new Track Segment
GameObject newTrackSegmentGo = new GameObject("Track segment");
// Set it as a child of this one
newTrackSegmentGo.transform.parent = transform;
// Add a Track Segment component to the newly created Game Object
TrackSegment newTrackSegment = newTrackSegmentGo.AddComponent <TrackSegment>();
// Set Line Renderer material
newTrackSegment.GroundMaterial = GroundMaterial;
// Add starting point
newTrackSegment.AddPoint(position);
// Add this new Track Segment to the whole Track
_track.Add(newTrackSegment);
break;
}
// If right button is pressed, switch mouse cursor to move
case PointerEventData.InputButton.Right:
{
Cursor.SetCursor(MoveCursor, new Vector2(32, 32), CursorMode.ForceSoftware);
break;
}
}
}
/*--------------------------------------------------------------------------------------------*/
public static void SplitTrackSegments(ReadOnlyCollection<TrackSegment> pSegments,
ReadOnlyCollection<TrackSegment> pCuts, IList<TrackSegment> pSliceResults) {
pSliceResults.Clear();
for ( int segI = 0 ; segI < pSegments.Count ; segI++ ) {
TrackSegment seg = pSegments[segI];
pSliceResults.Add(seg);
}
for ( int cutI = 0 ; cutI < pCuts.Count ; cutI++ ) {
TrackSegment cut = pCuts[cutI];
for ( int sliceI = 0 ; sliceI < pSliceResults.Count ; sliceI++ ) {
TrackSegment slice = pSliceResults[sliceI];
if ( cut.StartValue >= slice.StartValue && cut.EndValue <= slice.EndValue ) {
var slice2 = new TrackSegment();
slice2.StartValue = cut.EndValue;
slice2.EndValue = slice.EndValue;
slice2.IsFill = slice.IsFill;
pSliceResults.Insert(sliceI+1, slice2);
slice.EndValue = cut.StartValue;
pSliceResults[sliceI] = slice;
continue;
}
if ( cut.StartValue >= slice.StartValue && cut.StartValue <= slice.EndValue ) {
slice.EndValue = cut.StartValue;
pSliceResults[sliceI] = slice;
continue;
}
if ( cut.EndValue <= slice.EndValue && cut.EndValue >= slice.StartValue ) {
slice.StartValue = cut.EndValue;
pSliceResults[sliceI] = slice;
continue;
}
if ( cut.StartValue <= slice.StartValue && cut.EndValue >= slice.EndValue ) {
pSliceResults.RemoveAt(sliceI);
sliceI--;
}
}
}
for ( int sliceI = 0 ; sliceI < pSliceResults.Count ; sliceI++ ) {
TrackSegment slice = pSliceResults[sliceI];
if ( Math.Abs(slice.StartValue-slice.EndValue) <= 0.01f ) {
pSliceResults.RemoveAt(sliceI);
sliceI--;
}
}
}
public GpsData DeSerialize(StreamWrapper streamWrapper)
{
var data = new GpsData();
DateTime date = default(DateTime);
var trackSegment = new TrackSegment();
streamWrapper.Position = 0;
using (var reader = new StreamReader(streamWrapper))
{
string line;
while ((line = reader.ReadLine()) != null)
{
if (date == default(DateTime))
{
var match = Regex.Match(line, H_DATE_LINE_REGEX);
if (match.Success)
{
var d = int.Parse(match.Groups["d"].Value);
var m = int.Parse(match.Groups["m"].Value);
var y = int.Parse(match.Groups["y"].Value);
var yn = int.Parse(DateTime.UtcNow.ToString("yy"));
if (y > yn)
yn += 100;
var yd = yn - y;
date = new DateTime(DateTime.UtcNow.Year -yd, m, d);
continue;
}
}
if (ParseMetadata(data, x => x.Vehicle.Model, H_GLIDER_TYPE_REGEX, line))
continue;
if (ParseMetadata(data, x => x.Vehicle.Identifier, H_GLIDER_REG_REGEX, line))
continue;
if (ParseMetadata(data, x => x.Vehicle.Crew1, H_CREW1_REGEX, line))
continue;
if (ParseMetadata(data, x => x.Vehicle.Crew2, H_CREW2_REGEX, line))
continue;
if (ParseFix(line, trackSegment, date))
continue;
}
}
if (!trackSegment.IsEmpty())
{
data.Tracks.Add(new Track());
data.Tracks[0].Segments.Add(trackSegment);
}
return data;
}
public static Quaternion SectionGetRotation(TrackSegment section)
{
// Obtiene las posiciones
Vector3 sectionPosition = section.position;
Vector3 nextPosition = section.next.position;
// Obtiene la direccion y la normal de las posiciones
Vector3 forward = (nextPosition - sectionPosition);
Vector3 normal = section.normal;
// Devuelve lookat
return Quaternion.LookRotation(forward.normalized, normal.normalized);
}
/*--------------------------------------------------------------------------------------------*/
public static TrackSegment[] SplitTrackSegments(TrackSegment[] pSegments, TrackSegment[] pCuts)
{
var slices = pSegments.ToList();
foreach ( TrackSegment cut in pCuts ) {
for ( int i = 0 ; i < slices.Count ; i++ ) {
TrackSegment slice = slices[i];
if ( cut.StartValue >= slice.StartValue && cut.EndValue <= slice.EndValue ) {
var slice2 = new TrackSegment();
slice2.StartValue = cut.EndValue;
slice2.EndValue = slice.EndValue;
slice2.IsFill = slice.IsFill;
slices.Insert(i+1, slice2);
slice.EndValue = cut.StartValue;
slices[i] = slice;
continue;
}
if ( cut.StartValue >= slice.StartValue && cut.StartValue <= slice.EndValue ) {
slice.EndValue = cut.StartValue;
slices[i] = slice;
continue;
}
if ( cut.EndValue <= slice.EndValue && cut.EndValue >= slice.StartValue ) {
slice.StartValue = cut.EndValue;
slices[i] = slice;
continue;
}
if ( cut.StartValue <= slice.StartValue && cut.EndValue >= slice.EndValue ) {
slices.RemoveAt(i);
i--;
}
}
}
for ( int i = 0 ; i < slices.Count ; i++ ) {
TrackSegment slice = slices[i];
if ( Math.Abs(slice.StartValue-slice.EndValue) <= 0.01f ) {
slices.RemoveAt(i);
i--;
}
}
return slices.ToArray();
}
/// <summary>Нарезает трек на сегменты</summary>
private static IList<TrackSegment> SliceForSegments(GpsTrack Track)
{
if (Track.TrackPoints.Count == 0)
return new TrackSegment[0];
if (Track.TrackPoints.Count == 1)
return new[] { new TrackSegment(Track.TrackPoints[0], Track.TrackPoints[0], 0) };
double offset = 0;
var res = new List<TrackSegment>(Track.TrackPoints.Count - 1);
for (int i = 1; i < Track.TrackPoints.Count; i++)
{
var segment = new TrackSegment(Track.TrackPoints[i - 1], Track.TrackPoints[i], offset);
offset = segment.EndOffset;
res.Add(segment);
}
return res;
}
private bool ParseFix(string line, TrackSegment trackSegment)
{
if (line.IsNullOrWhitespace())
return false;
var match = Regex.Match(line, FIX_SENTENCE);
if (match.Success)
{
int h = int.Parse(match.Groups["h"].Value);
int m = int.Parse(match.Groups["m"].Value);
double s = double.Parse(match.Groups["s"].Value);
double alt = double.Parse(match.Groups["alt"].Value);
double lat = ConvertOrd(match.Groups["lat"].Value, match.Groups["latd"].Value);
double lon = ConvertOrd(match.Groups["lon"].Value, match.Groups["lond"].Value);
var fix = new Fix(lat, lon, alt, DateTime.MinValue.AddHours(h).AddMinutes(m).AddSeconds(s));
trackSegment.Fixes.Add(fix);
return true;
}
return false;
}
public GpsData DeSerialize(StreamWrapper streamWrapper)
{
var data = new GpsData();
var trackSegment = new TrackSegment();
streamWrapper.Position = 0;
using (var reader = new StreamReader(streamWrapper))
{
string line;
while ((line = reader.ReadLine()) != null)
{
if (ParseFix(line, trackSegment))
continue;
if (ParseWaypoint(line, data))
continue;
}
}
if (!trackSegment.IsEmpty())
{
data.Tracks.Add(new Track());
data.Tracks[0].Segments.Add(trackSegment);
}
return data;
}
/// <summary>
///
/// </summary>
private void SegmentEditor()
{
if (segmentEditMode == 0) {
if (selectedSegment != null) {
selectedSegment.position = Handles.PositionHandle(selectedSegment.position, Helpers.SectionGetRotation(selectedSegment));
}
}
RaycastHit hit;
Vector3[] verts = new Vector3[4];
Ray ray = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
// reset hover selection
managerData.trackData.editorSectionHover = -1;
// Borrar la info del segmento
for (int i = 0; i < segmentInfo.Length; ++i)
segmentInfo[i] = "";
if (Physics.Raycast(ray, out hit, Mathf.Infinity, 1 << LayerMask.NameToLayer("Track"))) {
HandleUtility.Repaint();
// Obtener tile de la mesh
Mesh m = hit.transform.GetComponent<MeshFilter>().sharedMesh;
TrackTile tile = Helpers.TileFromTriangleIndex(hit.triangleIndex, managerData.trackData.mappedTiles);
// Seleccionar segmento (Left Ctrl)
if ((Event.current.type == EventType.keyDown && Event.current.keyCode == KeyCode.LeftControl) || updatedSelected) {
updatedSelected = false;
selectedSegment = tile.segment;
customIndex = tile.segment.index;
managerData.trackData.editorSectionCurrent = selectedSegment.index;
managerData.trackData.editorSectionNext = selectedSegment.next.index;
}
// Asignar siguiente segmento
if (segmentEditMode == 1) {
if (Event.current.type == EventType.keyDown && Event.current.keyCode == KeyCode.Space) {
selectedSegment.next = tile.segment;
managerData.trackData.editorSectionNext = tile.segment.index;
}
}
managerData.trackData.editorSectionHover = tile.segment.index;
}
// Actualizar la información del segmento
if (selectedSegment != null) {
segmentInfo[0] = "Segment Index: " + selectedSegment.index;
segmentInfo[1] = "Segment Type: " + selectedSegment.type;
segmentInfo[2] = "Segment Tiles: " + selectedSegment.tiles[0].index + " & " + selectedSegment.tiles[1].index;
segmentInfo[3] = "Segment Width: " + selectedSegment.width;
segmentInfo[4] = "Segment Height: " + selectedSegment.height;
segmentInfo[5] = "Segment Next: " + selectedSegment.next.index;
}
}
private static void SegmentEdit()
{
segmentEditMode = GUILayout.Toolbar(segmentEditMode, new string[2] { "Set Position", "Set Next" });
if (selectedSegment != null) {
if (GUILayout.Button("Selext Next Segment")) {
HandleUtility.Repaint();
// Asignar el segmento siguiente al seleccionado
updatedSelected = true;
selectedSegment = selectedSegment.next;
customIndex = selectedSegment.index;
}
}
if (GUILayout.Button("Set Selected To Start")) {
int i;
for (i = 0; i < managerData.trackData.sections.Count; ++i) {
if (managerData.trackData.sections[i] == selectedSegment)
managerData.trackData.sectionStart = i;
}
}
if (GUILayout.Button("Reverse Track")) {
int i;
for (i = 0; i < managerData.trackData.sections.Count; ++i) {
if (i > 0)
managerData.trackData.sections[i].next = managerData.trackData.sections[i - 1];
else
managerData.trackData.sections[i].next = managerData.trackData.sections[managerData.trackData.sections.Count - 1];
}
}
// info
GUILayout.Space(10);
for (int i = 0; i < segmentInfo.Length; ++i)
GUILayout.Label(segmentInfo[i]);
}
private void _GetTracks(ArrayList TrackInformation, GPX gpxfile)
{
//Die passende SQLite Tabelle lasen
System.Data.DataTable datatableWP = _sqlitebase.ExecuteQuery("SELECT * FROM \"WP\"");
System.Data.DataTable datatableGPS= _sqlitebase.ExecuteQuery("SELECT * FROM \"GPSLog\"");
//Für jeden Track ausführen:
foreach (SQLiteTracks sqlitetrack in TrackInformation)
{
//Tracksegment erstellen
TrackSegment tracksegment = new TrackSegment();
//Variablen erstellen
double latitude,longitude,elevation;
DateTime gpxdatetime;
//Alle Punkte in der DB ablaufen
for (int i = sqlitetrack.FirstWP; i < sqlitetrack.LastWP; i++)
{
//Punktdaten holen
latitude = (float) (datatableWP.Rows[i][9]);
longitude = (float) datatableWP.Rows[i][8];
elevation = (float) datatableWP.Rows[i][10];
gpxdatetime = DateTime.FromFileTime((((long)(int)datatableGPS.Rows[i][2]) << 32)+(int)datatableGPS.Rows[i][3]);
//Wenn Sommerzeit war, dann ziehe eine Stunde ab
TimeZone localZone = TimeZone.CurrentTimeZone;
if(localZone.IsDaylightSavingTime(gpxdatetime))
{
gpxdatetime = gpxdatetime.AddHours(-1);
}
//Zu UTC konvertieren
gpxdatetime = gpxdatetime.ToUniversalTime();
//Punkt erstellen
DanielLibrary.GPXWriter.Utils.Point pointtmp = new Point(latitude,longitude,elevation,gpxdatetime);
//Punkt zum Segment hinzufügen
tracksegment.AddPoint(pointtmp);
}
//Track erstellen
Track track = new Track();
//Track, Segment und GPX verbinden
track.AddSegment(tracksegment);
gpxfile.AddTrack(track);
}
}
private TrackSegment createSection(Vector3[] normals, Vector3[] verts, TrackTile[] tiles, Transform floorT, Data gen, int i, int index)
{
TrackSegment newSection = new TrackSegment();
newSection = gen.sectionsObject.AddComponent<TrackSegment>();
newSection.hideFlags = HideFlags.HideInInspector;
tiles[0] = gen.tiles[i];
tiles[1] = gen.tiles[i + 1];
newSection.type = E_SEGMENTTYPE.NORMAL;
newSection.tiles = tiles;
newSection.index = index;
// Establecer la posicion de la seccion
Vector3 position1 = floorT.transform.TransformPoint(verts[tiles[0].indices[0]]);
Vector3 position2 = floorT.transform.TransformPoint(verts[tiles[1].indices[1]]);
Vector3 positionMid = (position1 + position2) / 2;
newSection.position = positionMid;
// Establecer la normal de la seccion
Vector3 normal1 = floorT.transform.TransformDirection(normals[tiles[0].indices[0]]);
Vector3 normal2 = floorT.transform.TransformDirection(normals[tiles[1].indices[1]]);
Vector3 normalMid = (normal1 + normal2) / 2;
newSection.normal = normalMid;
return newSection;
}
private bool ParseFix(string line, TrackSegment trackSegment, DateTime date)
{
if (string.IsNullOrWhiteSpace(line))
return false;
var match = Regex.Match(line, B_LINE_REGEX);
if (match.Success)
{
string h = match.Groups["h"].Value;
string m = match.Groups["m"].Value;
string s = match.Groups["s"].Value;
string coord = match.Groups["coord"].Value;
string validAlt = match.Groups["validAlt"].Value;
string presAlt = match.Groups["presAlt"].Value;
string gpsAlt = match.Groups["gpsAlt"].Value;
var cood = ParseCoordinate(coord);
var fix = new Fix(cood.Latitude, cood.Longitude, double.Parse(gpsAlt), date.AddHours(int.Parse(h)).AddMinutes(int.Parse(m)).AddSeconds(int.Parse(s)));
trackSegment.Fixes.Add(fix);
return true;
}
return false;
}
private Quaternion SectionGetRotation(TrackSegment section)
{
// Obtener las posiciones de la seccion y su siguiente
Vector3 sectionPosition = section.position;
Vector3 nextPosition = section.next.position;
// Calcular la distacia entre la posiciones y la normal
Vector3 forward = (nextPosition - sectionPosition);
Vector3 normal = section.normal;
// Devolver la rotacion
return Quaternion.LookRotation(forward.normalized, normal.normalized);
}
private void IndexSections()
{
TrackSegment[] sections = trackData.trackData.sections.ToArray();
TrackSegment startSection = sections[trackData.trackData.sectionStart];
startSection.index = 0;
int index = 1;
int maxIteration = 100000;
int iteration = 0;
TrackSegment currentSection = startSection.next;
bool ended = false;
while (!ended && iteration < maxIteration) {
currentSection.index = index;
currentSection = currentSection.next;
if (currentSection.next == startSection)
endSection = currentSection;
if (currentSection == startSection)
ended = true;
++index;
++iteration;
}
}
void OnTriggerEnter(Collider other)
{
Debug.Log(other.tag);
if (other.tag == "Checkpoint1") {
if (secondSector || currentLap == 0) {
UpdateLap();
secondSector = false;
}
}
if (other.tag == "Checkpoint2") {
if (currentLap > 0 && currentLap <= RaceSettings.laps)
sector1[currentLap - 1] = currentTime;
secondSector = true;
midSection = currentSection;
}
}
void Start()
{
laps = new float[RaceSettings.laps];
sector1 = new float[RaceSettings.laps];
sector2 = new float[RaceSettings.laps];
perfects = new bool[RaceSettings.laps];
if (!isNetworked) {
input.OnStart();
effects.OnStart();
music.OnStart();
ai.OnStart();
control.OnStart();
}
position.OnStart();
trackTransform = new GameObject("TrackTransform");
trackTransform.transform.parent = base.transform;
secondSector = true;
midSection = RaceSettings.raceManager.trackData.trackData.sections[RaceSettings.raceManager.trackData.trackData.sections.Count / 2];
}
public void AddSegment(TrackSegment segment)
{
segments.Add(segment);
}
