SHARE
TWEET

Untitled

Povstalez Jul 17th, 2017 45 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. using UnityEngine;
  2. using System.Collections;
  3. using System.Collections.Generic;
  4. using System;
  5. using System.Linq;
  6. using System.Threading;
  7. //using DG.Tweening;
  8. using UnityEngine.UI;
  9. using SmartLocalization;
  10. using UnityBluetoothLibrary;
  11.  
  12.  
  13.  
  14. public class TractorController : MonoBehaviour
  15. {
  16.     public GameObject Arrow;
  17.     public List<GameObject> trailer;
  18.     public Transform trackedPoint;
  19.     public Transform trackedPointRotation;
  20.     public GameObject loadingScreen;
  21.     public Text LoadingText;
  22.     public float maxSteeringAngle;
  23.     public ParticleSystem Particle;
  24.     public GameObject NextPoint;
  25.     public GameObject Sphere;
  26.     public List<GameObject> Points;
  27.     public Material NextPointMaterial;
  28.     public Material PassedPointMaterial;
  29.     public GameObject[] RotateFrontWheels;
  30.     public GameObject[] FrontWheels;
  31.     public GameObject[] RearWheels;
  32.     private Vector3 _zeroPoint = Vector3.zero;
  33.     public GameObject carLightTexture;
  34.  
  35.     private Vector2 firstPosition = Vector2.zero;
  36.     private double lastTimestamp;
  37.     private List<double> llastTimestamp;
  38.     private GameObject parent;
  39.     public bool isMoving = false;
  40.     public bool moved = false;
  41.     private bool enabledFilter = true;
  42.  
  43.  
  44.     public Text speedText;
  45.     public Text speedKMText;
  46.     public Text movedDistanceText;
  47.     public Text filledDistanceText;
  48.     public Text altitudeText;
  49.     public Text altitudeAdditionalText;
  50.  
  51.     //Sattelites
  52.     public Text sattelitesCountText;
  53.     public Text hdop2Text;
  54.     public Text qualityText;
  55.  
  56.     public Text btText;
  57.  
  58.     public Text debugText;
  59.  
  60.     public GameObject light;
  61.     public GameObject lightAir;
  62.     public GameObject lights;
  63.  
  64.     public List<FilledArea> filledAreas;
  65.  
  66.     public List<HingeJoint> trailerJoint;
  67.  
  68.     AndroidJavaObject gpsActivityJavaClass;
  69.     private Vector3 lastBackPoint = Vector3.zero;
  70.  
  71.     private float movedDistance = 0;
  72.     private float filledDistance = 0;
  73.  
  74.     public float Gz = 0.1f;
  75.     public float pointsDealey = 0.5f;
  76.     public int sectorsDealey = 2;
  77.     public float speedLimit = 1f;
  78.     public float smDealey = 15;
  79.  
  80.     private float startingDistance = 0;
  81.     private float startingFillingDistance = 0;
  82.  
  83.     public bool needToAddPosition = true;
  84.     public bool needToAddSquare = true;
  85.     public string forGoogleString;
  86.     public string forKML;
  87.     public string forKMLLeft;
  88.     public string forKMLRight;
  89.     public List<string> kmlRightList;
  90.     public string gpxString;
  91.     public string kmlSquare;
  92.     public string kmlStartSquare;
  93.     private bool isDemo = false;
  94.  
  95.     public bool IsConnected = false;
  96.  
  97.     public Camera ScreenshotCamera;
  98.  
  99.     public Transform tractorTrasform;
  100.     public Transform arrowTransform;
  101.  
  102.     public static TractorController Instance;
  103.  
  104.     public string startingDate = "";
  105.     public string currentDate = "";
  106.  
  107.     public GameObject mainCamera;
  108.  
  109.     private int movedCount = 0;
  110.  
  111.     public Transform airship;
  112.     public GameObject airshipLine;
  113.     public Transform MainTransform;
  114.     public Transform airPropeller;
  115.  
  116.     public Material GrounMaterial;
  117.     public GameObject GroundGameObject;
  118.     private List<float> speeds = new List<float>();
  119.     private int minSpeed = 0;
  120.     private int maxSpeed = 0;
  121.  
  122.     //Combine
  123.     public Transform CombineTransform;
  124.     public GameObject CombineLeftRear;
  125.     public GameObject CombineRightRear;
  126.     public GameObject CombineLeftFront;
  127.     public GameObject CombineRightFront;
  128.     public float altOffset = 0;
  129.  
  130.     public float overSquare = 0;
  131.  
  132.     public GameObject CalibrationWindow;
  133.     private Vector3 offsetPos = Vector3.zero;
  134.     public Vector3 lastPositionSave = Vector3.zero;
  135.     public Collider lastArea;
  136.     public bool isContinue = false;
  137.  
  138.     public bool IsOriginalDevice = false;
  139.  
  140.     public GameObject CommasGameObject;
  141.     public LineRenderer AirLine;
  142.     public Transform AirPoint;
  143.  
  144.     public Transform MapTransform;
  145.  
  146.     public bool TryToConnectBt = true;
  147.  
  148. #if !UNITY_EDITOR && UNITY_WSA_10_0
  149.     private UnityBluetooth uBluetooth;
  150.  
  151. #endif
  152.     void Awake()
  153.     {
  154.         if (PlayerPrefs.HasKey("lang"))
  155.         {
  156.             LanguageManager.Instance.ChangeLanguage(PlayerPrefs.GetString("lang"));
  157.         }
  158.         else
  159.         {
  160.             SmartCultureInfo deviceCulture = LanguageManager.Instance.GetDeviceCultureIfSupported();
  161.             if (deviceCulture != null)
  162.             {
  163.                 LanguageManager.Instance.ChangeLanguage(deviceCulture);
  164.             }
  165.             else
  166.             {
  167.                 LanguageManager.Instance.ChangeLanguage("ru");
  168.             }
  169.         }
  170.         if (SaveController.Instance.data.startingPos != Vector2.zero)
  171.         {
  172.             isContinue = true;
  173.             lastPositionSave = new Vector3(PlayerPrefs.GetFloat("posX" + SaveController.Instance.data.saveIndex), transform.position.y, PlayerPrefs.GetFloat("posZ" + SaveController.Instance.data.saveIndex));
  174.  
  175.         }
  176.  
  177.         Instance = this;
  178.     }
  179.  
  180.     void Start()
  181.     {
  182.         try
  183.         {
  184.             Screen.sleepTimeout = SleepTimeout.NeverSleep;
  185.  
  186.             if (SaveController.Instance.data.startingPos != Vector2.zero)
  187.             {
  188.                 CalibrationWindow.SetActive(true);
  189.                 isContinue = true;
  190.             }
  191.  
  192.             if(SaveController.Instance.data.isAccelerator)
  193.             {
  194.                 hdop2Text.gameObject.SetActive(false);
  195.                 hdop2Text.text = "";
  196.                 sattelitesCountText.gameObject.SetActive(false);
  197.                 sattelitesCountText.text = "";
  198.                 demoText.SetActive(true);
  199.                 altitude = 148;
  200.                 sattelitesCountText.text = LanguageManager.Instance.GetTextValue("SattelitesLbl") + "21";
  201.                 hdop2Text.text = "HDOP: 0.6";
  202.             }
  203.  
  204.             Invoke("AfterStart", 1);
  205.             IsOriginalDevice = PlayerPrefs.GetInt("VelestorDevice") == 1;
  206.             //LoadCoordinatesByName("10m", 10);
  207.             mainCamera = GameObject.FindGameObjectWithTag("Camera");
  208.  
  209.             if (CheckWorkType.Instance.typeId == 8)
  210.             {
  211.                 CommasGameObject.SetActive(true);
  212.                 airshipLine.SetActive(true);
  213.             }
  214.         }
  215.         catch
  216.         {
  217.            
  218.         }
  219.     }
  220.  
  221.     public GameObject demoText;
  222.  
  223.     private void AfterStart()
  224.     {
  225.         try
  226.         {
  227.             if (!SaveController.Instance.data.isAccelerator)
  228.             {
  229. #if UNITY_STANDALONE
  230.             WinBluetoothController.Instance.StartConnect();
  231.             Debug.Log("Start connect");
  232. #endif
  233.             }
  234.             else
  235.             {
  236.                 sattelitesCountText.text = LanguageManager.Instance.GetTextValue("SattelitesLbl") + "21";
  237.             }
  238. #if !UNITY_ANDROID
  239.             if (!IsOriginalDevice)
  240.                 MainGUI.Instance.OpenOriginalPopup();
  241. #endif
  242.  
  243.  
  244.             llastTimestamp = new List<double>();
  245.             SaveController.Instance.TryToLoad();
  246.             movedDistance = SaveController.Instance.data.distance;
  247.             filledDistance = SaveController.Instance.data.filledDistance;
  248.             startingDistance = movedDistance;
  249.             startingFillingDistance = filledDistance;
  250.             filledDistanceText.text = (Math.Round((startingFillingDistance), 2)).ToString();
  251.             movedDistance = 0;
  252.             filledDistance = 0;
  253.             SetMovedText();
  254.             parent = new GameObject("test");
  255.             parent.gameObject.transform.SetParent(NextPoint.gameObject.transform.parent, false);
  256.             SetDebugValues();
  257.  
  258.             if (PlayerPrefs.GetInt("VelestorDevice") == 0)
  259.             {
  260.                 mainCamera = MouseOrbitImproved.Instance.twoDCamera;
  261.             }
  262.  
  263.             if (SaveController.Instance.data.startingPos != Vector2.zero)
  264.             {
  265.                 firstPosition = SaveController.Instance.data.startingPos;
  266.                 startingDate = PlayerPrefs.GetString("date" + SaveController.Instance.data.saveIndex);
  267.             }
  268.  
  269.             if (CheckWorkType.Instance.typeId == 8)
  270.             {
  271.                 StartCoroutine(TrackAirRotation());
  272.                 //loadingScreen.transform.localPosition = new Vector3(loadingScreen.transform.localPosition.x, 11,
  273.                 //   loadingScreen.transform.localPosition.z);
  274.  
  275.             }
  276.             else
  277.             {
  278.                 //light.SetActive(true);
  279.                 lightAir.SetActive(false);
  280.  
  281.             }
  282.  
  283.             if (CheckWorkType.Instance.typeId == 5)
  284.             {
  285.                 mainCamera = MouseOrbitImproved.Instance.twoDCamera;
  286.                 RotateFrontWheels[0] = CombineLeftFront;
  287.                 RotateFrontWheels[1] = CombineRightFront;
  288.                 FrontWheels[0] = CombineLeftFront;
  289.                 FrontWheels[1] = CombineRightFront;
  290.                 RearWheels[0] = CombineLeftRear;
  291.                 RearWheels[1] = CombineRightRear;
  292.                 float nowSize = (float) (MetricsWindow.Instance.metrics + ((float) MetricsWindow.Instance.sm / 100)) - 4;
  293.                 nowSize *= 10;
  294.                 MouseOrbitImproved.Instance.distance += nowSize;
  295.             }
  296.  
  297.             ScreenshotCamera.gameObject.SetActive(false);
  298.             forGoogleString = PlayerPrefs.GetString("map" + SaveController.Instance.data.saveIndex);
  299.             forKML = PlayerPrefs.GetString("kml" + SaveController.Instance.data.saveIndex);
  300.             string mac = PlayerPrefs.GetString("mac");
  301.             string pin = PlayerPrefs.GetString("pin");
  302.             string deviceName = PlayerPrefs.GetString("device");
  303.             if (!SaveController.Instance.data.isAccelerator)
  304.             {
  305. #if UNITY_ANDROID
  306.         AndroidJNI.AttachCurrentThread();
  307.  
  308.         if (SaveController.Instance.gpsActivityJavaClass == null)
  309.         {
  310.             using (var javaUnityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
  311.             {
  312.                 using (var currentActivity = javaUnityPlayer.GetStatic<AndroidJavaObject>("currentActivity"))
  313.                 {
  314.                     gpsActivityJavaClass = new AndroidJavaObject("com.velestor.tractor.GPSTest", currentActivity);
  315.                     //string testtt = gpsActivityJavaClass.CallStatic<string>("LockHome");
  316.                     SaveController.Instance.gpsActivityJavaClass = gpsActivityJavaClass;
  317.                 }
  318.             }
  319.         }
  320.         else
  321.         {
  322.             gpsActivityJavaClass = SaveController.Instance.gpsActivityJavaClass;
  323.         }
  324.                 string test = "";
  325.                 if (!SaveController.Instance.data.isInner)
  326.                     test = gpsActivityJavaClass.CallStatic<string>("SetAdress", mac, pin, deviceName);
  327.                 else
  328.                 {
  329.                     SetDebugText("Try start gps");
  330.                     test = gpsActivityJavaClass.CallStatic<string>("StartInnerGPS",LanguageManager.Instance.GetTextValue("InnerGPSEnable"), LanguageManager.Instance.GetTextValue("Yes"), LanguageManager.Instance.GetTextValue("No"));
  331.                     SetDebugText(test);
  332.                 }
  333.  
  334.             StartCoroutine(GetNMEA());
  335. #endif
  336. #if UNITY_STANDALONE
  337.             StartCoroutine(GetNMEA());
  338.  
  339. #endif
  340.  
  341.                 if (SaveController.Instance.data.debugFileName == "-")
  342.                 {
  343.                     loadingScreen.SetActive(true);
  344.                     StartCoroutine(GetPositions());
  345.                     StartCoroutine(GetPositionsFromBluetooth());
  346.                 }
  347.                 if (SaveController.Instance.data.debugFileName != "-")
  348.                 {
  349.                     isDemo = true;
  350. #if UNITY_EDITOR || UNITY_WSA
  351.                     StartCoroutine(GetPositions());
  352. #endif
  353.                     StartCoroutine(GetPositionsFromNMEA());
  354.                 }
  355.  
  356.  
  357. #if !UNITY_EDITOR && UNITY_WSA_10_0
  358.         uBluetooth = new UnityBluetooth();
  359.  
  360.         uBluetooth.StartBT (mac, pin, deviceName, ConstConfig.isInnerGPS);
  361. #endif
  362.             }
  363.             else
  364.             {
  365.                 foreach (GameObject go in trailer)
  366.                     go.transform.SetParent(null);
  367.             }
  368.  
  369.             //string test = gpsActivityJavaClass.CallStatic<string>("SetAdress", "55:7D:C3:6D:62:61", "0183","Smart watch");
  370.             //btText.text = test;
  371.             //transform.position = new Vector3(NextPoint.transform.position.x, gameObject.transform.position.y, NextPoint.transform.position.z);
  372.         }
  373.         catch (Exception e)
  374.         {
  375.  
  376.         }
  377.  
  378.     }
  379.  
  380.     private bool isCalibrated = false;
  381.  
  382.     public void Calibrate()
  383.     {
  384.         try
  385.         {
  386.             if (lastArea != null && isContinue && !isCalibrated)
  387.             {
  388.                 if (movCor != null)
  389.                 {
  390.                     StopCoroutine(movCor);
  391.                 }
  392.                 List<Vector3> vert = ((MeshCollider)lastArea).sharedMesh.vertices.ToList();
  393.                 Vector3 start = (vert[0] + vert[1]) / 2;
  394.                 Vector3 end = (vert[vert.Count - 1] + vert[vert.Count - 2]) / 2;
  395.                 if (Vector3.Distance(start, transform.position) > Vector3.Distance(end, transform.position))
  396.                 {
  397.                     MoveTractor(new Vector3(end.x, transform.position.y, end.z));
  398.                 }
  399.                 else
  400.                 {
  401.                     MoveTractor(new Vector3(start.x, transform.position.y, start.z));
  402.                 }
  403.                 isCalibrated = true;
  404.             }
  405.             CalibrationWindow.SetActive(false);
  406.         }catch
  407.         {
  408.             CalibrationWindow.SetActive(false);
  409.         }
  410.  
  411.     }
  412.  
  413.     private void MoveTractor(Vector3 to)
  414.     {
  415.         GameObject[] areas = GameObject.FindGameObjectsWithTag("Areas");
  416.  
  417.         MainTransform.SetParent(transform);
  418.         //transform.position = to + transform.forward *((-MainTransform.localPosition.z) * 6.278354f);
  419.         MainTransform.localEulerAngles = Vector3.zero;
  420.         MainTransform.localPosition = new Vector3(0, MainTransform.localPosition.y, MainTransform.localPosition.z);
  421.  
  422.         foreach (var obj in areas)
  423.         {
  424.             obj.transform.position = obj.transform.position + ((transform.position - to) - transform.forward * ((-MainTransform.localPosition.z) * 6.278354f));
  425.             if (obj.transform.parent != null)
  426.             {
  427.                 obj.transform.localPosition = Vector3.zero;
  428.             }
  429.         }
  430.  
  431.         MainTransform.SetParent(null);
  432.  
  433.  
  434.         Points.Clear();
  435.         pointsCount = 0;
  436.         selectedPoints.Clear();
  437.         ponitCount = 0;
  438.     }
  439.  
  440.     private void SetDebugValues()
  441.     {
  442.         QualitySettings.vSyncCount = 0;  // VSync must be disabled
  443.         Application.targetFrameRate = 30;
  444.         SaveController.Instance.needToSave = true;
  445.         if (CheckWorkType.Instance.typeId != 5)
  446.         {
  447.             SetZOffset(SaveController.Instance.data.zOffset + (float) SaveController.Instance.data.zSMOffset / 100);
  448.         }
  449.         else
  450.         {
  451.             SetZOffset(4);
  452.         }
  453.         if (SaveController.Instance.data.debugData.pointsDealey == 1 && SaveController.Instance.data.debugData.sectorDealey == 1)
  454.         {
  455.             SaveController.Instance.data.debugData.sectorDealey = 2;
  456.             SaveController.Instance.data.debugData.pointsDealey = 0.5f;
  457.         }
  458.  
  459.         pointsDealey = SaveController.Instance.data.debugData.pointsDealey * 10;
  460.         sectorsDealey = SaveController.Instance.data.debugData.sectorDealey;
  461.         speedLimit = SaveController.Instance.data.debugData.minSpeed;
  462.         smDealey = SaveController.Instance.data.overlapM;
  463.  
  464.  
  465.  
  466.         minX = PlayerPrefs.GetFloat("minX" + SaveController.Instance.data.saveIndex);
  467.         maxX = PlayerPrefs.GetFloat("maxX" + SaveController.Instance.data.saveIndex);
  468.         minY = PlayerPrefs.GetFloat("minY" + SaveController.Instance.data.saveIndex);
  469.         maxY = PlayerPrefs.GetFloat("maxY" + SaveController.Instance.data.saveIndex);
  470.  
  471.         if (SaveController.Instance.data.isNewSave)
  472.         {
  473.             SaveController.Instance.data.isNewSave = false;
  474.             SaveController.Instance.InsertShortSave(SaveController.Instance.data);
  475.         }
  476.        
  477.     }
  478.  
  479.     public void SetOverlapSM(int sm)
  480.     {
  481.         smDealey = sm;
  482.     }
  483.  
  484.     private float normalOffset = 0;
  485.  
  486.     public void SetZOffset(float offset, float plus = 1)
  487.     {
  488.         if (plus == 1)
  489.         {
  490.             normalOffset = offset;
  491.             foreach (HingeJoint joint in trailerJoint)
  492.                 joint.anchor = new Vector3(0, 0, -0.5f);
  493.         }
  494.         else if (plus == 0)
  495.         {
  496.             foreach (HingeJoint joint in trailerJoint)
  497.                 joint.anchor = new Vector3(0, 0, 0);
  498.         }
  499.  
  500.         foreach (HingeJoint joint in trailerJoint)
  501.             joint.connectedAnchor = new Vector3(0, 0, (offset + plus));
  502.     }
  503.  
  504.     public void SetDebugText(string debug)
  505.     {
  506.         debugText.text = debug;
  507.         //debugText.gameObject.SetActive(true);
  508.     }
  509.  
  510.     public void UnpairBt()
  511.     {
  512. #if !UNITY_EDITOR && UNITY_ANDROID
  513.         gpsActivityJavaClass.CallStatic<string>("UnpairBt");
  514. #elif !UNITY_EDITOR && UNITY_WSA_10_0
  515.         uBluetooth.StopTimer();
  516. #elif UNITY_STANDALONE
  517.         //WinBluetoothController.Instance.RequestDisconnect();
  518. #endif
  519.         IsConnected = false;
  520.     }
  521.  
  522.     void OnApplicationPause(bool pauseStatus)
  523.     {
  524.         if (pauseStatus)
  525.         {
  526.             if (SaveController.Instance.data.isInner)
  527.             {
  528.                 //gpsActivityJavaClass.CallStatic<string>("StartInnerGPS");
  529.             }
  530. #if !UNITY_EDITOR && UNITY_ANDROID
  531.             UnpairBt();
  532. #endif
  533.         }
  534.         else
  535.         {
  536. #if !UNITY_EDITOR && UNITY_ANDROID
  537.             if(!IsOriginalDevice)
  538.                 gpsActivityJavaClass.CallStatic<string>("ShowOriginalText", LanguageManager.Instance.GetTextValue("OriginalPopup"), LanguageManager.Instance.GetTextValue("OriginalPopupOk"));
  539. #else
  540.             if (!IsOriginalDevice)
  541.                 MainGUI.Instance.OpenOriginalPopup();
  542. #endif
  543.         }
  544.     }
  545.  
  546.     public void SendDowngradeBT()
  547.     {
  548. #if !UNITY_EDITOR && UNITY_ANDROID
  549.         if (!string.IsNullOrEmpty(PlayerPrefs.GetString("deviceSpeed")))
  550.         {
  551.             gpsActivityJavaClass.CallStatic<string>("SendData", "$PMTK300,1000,0,0,0,0*1C"+ "\r\n");
  552.         }
  553. #elif !UNITY_EDITOR && UNITY_WSA_10_0
  554.         string toSend = "$PMTK300,1000,0,0,0,0*1C" + "\r\n";
  555.                         uBluetooth.Send(toSend);
  556. #elif UNITY_STANDALONE
  557.         WinBluetoothController.Instance.Send("$PMTK300,1000,0,0,0,0*1C" + "\r\n");
  558. #endif
  559.     }
  560.  
  561.     void OnDestroy()
  562.     {
  563.  
  564.  
  565.         if(SaveController.Instance.data.isAccelerator)
  566.         {
  567.             PlayerPrefs.SetInt("Demo" + SaveController.Instance.data.saveIndex, 1);
  568.         }
  569.  
  570.         SaveController.Instance.needToSave = false;
  571. #if !UNITY_EDITOR && UNITY_WSA_10_0
  572.         if (uBluetooth != null)
  573.             uBluetooth.StopTimer();
  574.         else
  575.             return;
  576.  
  577.         string Phone =uBluetooth.Phone;
  578.  
  579.         for (int i = kmlRightList.Count - 1; i >= 0; i--)
  580.         {
  581.             forKMLRight += kmlRightList[i];
  582.         }
  583.         PlayerPrefs.SetString("endDate" + SaveController.Instance.data.saveIndex, currentDate);
  584.         PlayerPrefs.SetString("kml" + SaveController.Instance.data.saveIndex, forKMLLeft + forKMLRight);
  585.         PlayerPrefs.SetString("phone" + SaveController.Instance.data.saveIndex, Phone);
  586.         PlayerPrefs.SetString("phoneName" + SaveController.Instance.data.saveIndex, uBluetooth.friendlyName);
  587.         if (!string.IsNullOrEmpty(forKMLLeft))
  588.         {
  589.             DownloadController.Instance.StartSendWork(SaveController.Instance.data.saveIndex, startingDate, currentDate, forKMLLeft + forKMLRight, SaveController.Instance.data.adress,
  590.             SaveController.Instance.data.description, SaveController.Instance.data.user, SaveController.Instance.data.type,
  591.             ((float)((float)SaveController.Instance.data.widthM + (float)SaveController.Instance.data.widthSM / 100)).ToString(), SaveController.Instance.data.distance.ToString(),
  592.             SaveController.Instance.data.filledDistance.ToString(), SaveController.Instance.data.square.ToString(),
  593.             "123", uBluetooth.friendlyName, SystemInfo.deviceUniqueIdentifier, Phone,false,SaveController.Instance.data);
  594.  
  595.         }
  596.         if (!string.IsNullOrEmpty(kmlSquare))
  597.         {
  598.             PlayerPrefs.SetString("square" + SaveController.Instance.data.saveIndex, kmlSquare + kmlStartSquare);
  599.             DownloadController.Instance.StartSendWork(SaveController.Instance.data.saveIndex, currentDate, kmlSquare + kmlStartSquare, SaveController.Instance.data.square.ToString(), SaveController.Instance.data.adress,
  600.                 SaveController.Instance.data.description, SaveController.Instance.data.user, SaveController.Instance.data.type,
  601.                 ((float)((float)SaveController.Instance.data.widthM + (float)SaveController.Instance.data.widthSM / 100)).ToString(), SaveController.Instance.data.distance.ToString(),
  602.                 SaveController.Instance.data.filledDistance.ToString(), SaveController.Instance.data.square.ToString(),
  603.                 "", SystemInfo.deviceModel, SystemInfo.deviceUniqueIdentifier, Phone, true,SaveController.Instance.data);
  604.         }
  605.  
  606. #else
  607.         List<string> polygonsList = new List<string>();
  608.         for (int i = kmlRightList.Count - 1; i >= 0; i--)
  609.         {
  610.             forKMLRight += kmlRightList[i];
  611.         }
  612.         PlayerPrefs.SetString("overlapSquare"+SaveController.Instance.data.saveIndex, overSquare.ToString());
  613.         PlayerPrefs.SetString("endDate" + SaveController.Instance.data.saveIndex, currentDate);
  614.         PlayerPrefs.SetString("kml" + SaveController.Instance.data.saveIndex, forKMLLeft + forKMLRight);
  615.         PlayerPrefs.SetString("gpx" + SaveController.Instance.data.saveIndex, gpxString);
  616.         PlayerPrefs.SetInt("minSpeed" + SaveController.Instance.data.saveIndex, minSpeed);
  617.         PlayerPrefs.SetInt("maxSpeed" + SaveController.Instance.data.saveIndex, maxSpeed);
  618.         string Phone = "CantGetPhone";
  619. #if UNITY_ANDROID && !UNITY_EDITOR
  620.         Phone = gpsActivityJavaClass.CallStatic<string>("GetPhone");
  621.         string testtt = gpsActivityJavaClass.CallStatic<string>("UnLockHome");
  622. #endif
  623.         PlayerPrefs.SetString("phone" + SaveController.Instance.data.saveIndex, Phone);
  624.  
  625.         if (!string.IsNullOrEmpty(forKMLLeft) || SaveController.Instance.data.isAccelerator)
  626.         {
  627.             float averageSpeed = 0;
  628.             for (int i = 0; i < speeds.Count; i++)
  629.             {
  630.                 averageSpeed += speeds[i];
  631.             }
  632.             averageSpeed /= speeds.Count;
  633.             PlayerPrefs.SetFloat("averageSpeed" + SaveController.Instance.data.saveIndex, averageSpeed);
  634.             DownloadController.Instance.StartSendWork(SaveController.Instance.data.saveIndex, startingDate, currentDate, forKMLLeft + forKMLRight, SaveController.Instance.data.adress,
  635.                 SaveController.Instance.data.description, SaveController.Instance.data.user, SaveController.Instance.data.type,
  636.                 ((float)((float)SaveController.Instance.data.widthM + (float)SaveController.Instance.data.widthSM / 100)).ToString(), SaveController.Instance.data.distance.ToString(),
  637.                 SaveController.Instance.data.filledDistance.ToString(), SaveController.Instance.data.square.ToString(),
  638.                 Network.player.ipAddress, SystemInfo.deviceModel, SystemInfo.deviceUniqueIdentifier, Phone, false, SaveController.Instance.data,false,gpxString,minSpeed,maxSpeed,averageSpeed);
  639.  
  640.         }
  641.  
  642.         if (!string.IsNullOrEmpty(kmlSquare))
  643.         {
  644.             PlayerPrefs.SetString("square" + SaveController.Instance.data.saveIndex, kmlSquare + kmlStartSquare);
  645.             DownloadController.Instance.StartSendWork(SaveController.Instance.data.saveIndex, currentDate, kmlSquare + kmlStartSquare, SaveController.Instance.data.square.ToString(), SaveController.Instance.data.adress,
  646.                 SaveController.Instance.data.description, SaveController.Instance.data.user, SaveController.Instance.data.type,
  647.                 ((float)((float)SaveController.Instance.data.widthM + (float)SaveController.Instance.data.widthSM / 100)).ToString(), SaveController.Instance.data.distance.ToString(),
  648.                 SaveController.Instance.data.filledDistance.ToString(), SaveController.Instance.data.square.ToString(),
  649.                 Network.player.ipAddress, SystemInfo.deviceModel, SystemInfo.deviceUniqueIdentifier, Phone, true, SaveController.Instance.data);
  650.         }
  651.         UnpairBt();
  652. #endif
  653.     }
  654.  
  655.     public void SavePositions()
  656.     {
  657.         foreach (var control in MainRightPanel.Instance.controllers)
  658.         {
  659.             control.EndDrawLine();
  660.         }
  661.     }
  662.  
  663.     private string ScreenShotName(int width, int height)
  664.     {
  665.         return string.Format("{0}/screenshots/screen_{1}x{2}_{3}.png",
  666.                              Application.dataPath,
  667.                              width, height,
  668.                              System.DateTime.Now.ToString("yyyy-MM-dd_HH-mm-ss"));
  669.     }
  670.  
  671.     private void RenderNormalCamera()
  672.     {
  673.         if (MouseOrbitImproved.Instance.twoDCamera.activeSelf)
  674.         {
  675.             MouseOrbitImproved.Instance.twoDCamera.GetComponent<Camera>().Render();
  676.         }
  677.         else
  678.         {
  679.             MouseOrbitImproved.Instance.mCamera.GetComponent<Camera>().Render();
  680.         }
  681.  
  682.     }
  683.  
  684.     public void GetScreenshot()
  685.     {
  686.         try
  687.         {
  688.  
  689.  
  690.             SquareController.Instance.CheckInFinish();
  691.             //ScreenshotCamera.gameObject.SetActive(true);
  692.             ScreenshotCamera.transform.position = GetScreenshotPosition();
  693.             ScreenshotCamera.orthographicSize = GetOrthographicSize();
  694.             if (ScreenshotCamera.orthographicSize == 0)
  695.                 ScreenshotCamera.orthographicSize = 100;
  696.             if (ScreenshotCamera.orthographicSize <= 200)
  697.                 ScreenshotCamera.orthographicSize = 250;
  698.             RenderTexture rt = new RenderTexture(Screen.width, Screen.height, 24);
  699.             ScreenshotCamera.targetTexture = rt;
  700.             Texture2D screenShot = new Texture2D(Screen.width, Screen.height, TextureFormat.ARGB32, false);
  701.             ScreenshotCamera.Render();
  702.             //RenderNormalCamera();
  703.             RenderTexture.active = rt;
  704.             screenShot.ReadPixels(new Rect(0, 0, Screen.width, Screen.height), 0, 0);
  705.             ScreenshotCamera.targetTexture = null;
  706.             RenderTexture.active = null; // JC: added to avoid errors
  707.  
  708.             byte[] bytes = screenShot.EncodeToPNG();
  709.             string filename = Convert.ToBase64String(bytes);
  710.             SaveController.Instance.InsertSmallScreenshot(SaveController.Instance.data.saveIndex.ToString(), filename);
  711.             GetBigScreenshot();
  712.         }
  713.         catch (Exception ex)
  714.         {
  715.             PromptWindow.Instance._async.allowSceneActivation = true;
  716.         }
  717.     }
  718.  
  719.     public void GenerateSendData()
  720.     {
  721.         string toSend = "$VT,";
  722.         if (IndicatorPanel.Instance.metersText.text != "0")
  723.         {
  724.             if (speed > speedLimit)
  725.             {
  726.                 if (IndicatorPanel.Instance.arrow.localEulerAngles.z > 180)
  727.                 {
  728.                     toSend += "+" + IndicatorPanel.Instance.metersText.text;
  729.                 }
  730.                 else
  731.                 {
  732.                     toSend += "-" + IndicatorPanel.Instance.metersText.text;
  733.                 }
  734.             }
  735.             else
  736.             {
  737.                 toSend += "0";
  738.             }
  739.         }
  740.         else
  741.         {
  742.             toSend += IndicatorPanel.Instance.metersText.text;
  743.         }
  744.  
  745.         if (!MainRightPanel.Instance.Paint || speed < speedLimit)
  746.         {
  747.  
  748.             toSend += ",0,0,0,0,0,0,0,0,0";
  749.             float width = (float)SaveController.Instance.data.widthM + (float)SaveController.Instance.data.widthSM / 100;
  750.             float side = (float)SaveController.Instance.data.xOffset + (float)SaveController.Instance.data.xSMOffset / 100;
  751.             float distanceAntena = (float)SaveController.Instance.data.zOffset + (float)SaveController.Instance.data.zSMOffset / 100;
  752.             string additional = "," + (int)speed + "," + width + "," + distanceAntena + ",";
  753.             if (side > 0)
  754.             {
  755.                 additional += "+" + side;
  756.             }
  757.             else
  758.             {
  759.                 additional += side;
  760.             }
  761.             toSend += additional;
  762.  
  763.             toSend += "*";
  764.         }
  765.         else
  766.         {
  767.             for (int i = 0; i < 9; i++)
  768.             {
  769.                 if (i < TogglesPanel.Instance.toggleCount && TogglesPanel.Instance.toggleCount != 1)
  770.                 {
  771.                     toSend += ",";
  772.                     if (TogglesPanel.Instance.leftOutlines[i].IsWorking)
  773.                     {
  774.                         toSend += "1";
  775.                     }
  776.                     else
  777.                     {
  778.                         toSend += "0";
  779.                     }
  780.                 }
  781.                 else if (i < TogglesPanel.Instance.toggleCount && TogglesPanel.Instance.toggleCount == 1)
  782.                 {
  783.                     toSend += ",1";
  784.                 }
  785.                 else
  786.                 {
  787.                     toSend += ",0";
  788.                 }
  789.             }
  790.             float width = (float)SaveController.Instance.data.widthM + (float)SaveController.Instance.data.widthSM / 100;
  791.             float side = (float)SaveController.Instance.data.xOffset + (float)SaveController.Instance.data.xSMOffset / 100;
  792.             float distanceAntena = (float)SaveController.Instance.data.zOffset + (float)SaveController.Instance.data.zSMOffset / 100;
  793.             string additional = "," + (int)speed + "," + width + "," + distanceAntena + ",";
  794.             if (side > 0)
  795.             {
  796.                 additional += "+" + side;
  797.             }
  798.             else
  799.             {
  800.                 additional += side;
  801.             }
  802.             toSend += additional;
  803.  
  804.             toSend += "*";
  805.         }
  806.  
  807.         toSend += getChecksum(toSend) + "\r\n";
  808.  
  809. #if UNITY_EDITOR || !UNITY_WSA_10_0
  810.             if (gpsActivityJavaClass != null && PlayerPrefs.GetInt("VelestorDevice") == 1 &&
  811.                 PlayerPrefs.GetInt("control") == 1)
  812.             {
  813.                 gpsActivityJavaClass.CallStatic<string>("SendData", toSend);
  814.             }
  815. #if UNITY_STANDALONE
  816.  
  817.             if (PlayerPrefs.GetInt("VelestorDevice") == 1 &&
  818.                 PlayerPrefs.GetInt("control") == 1)
  819.             {
  820.                 WinBluetoothController.Instance.Send(toSend);
  821.             }
  822. #endif
  823.  
  824. #elif UNITY_WSA_10_0
  825.             if(PlayerPrefs.GetInt("VelestorDevice") == 1 && PlayerPrefs.GetInt("control") == 1)
  826.             {
  827.                 uBluetooth.Send(toSend);
  828.             }
  829. #endif
  830.  
  831.     }
  832.  
  833.     private static string getChecksum(string sentence)
  834.     {
  835.         int checksum = Convert.ToByte(sentence[sentence.IndexOf('$') + 1]);
  836.         for (int i = sentence.IndexOf('$') + 2; i < sentence.IndexOf('*'); i++)
  837.         {
  838.             checksum ^= Convert.ToByte(sentence[i]);
  839.         }
  840.         return checksum.ToString("X2");
  841.     }
  842.  
  843.     private void GetBigScreenshot()
  844.     {
  845.         try
  846.         {
  847.             ScreenshotCamera.transform.position = GetScreenshotPosition();
  848.             ScreenshotCamera.orthographicSize = GetOrthographicSize(true);
  849.             if (ScreenshotCamera.orthographicSize == 0)
  850.                 ScreenshotCamera.orthographicSize = 100;
  851.             RenderTexture rt = new RenderTexture(640, 720, 24);
  852.             ScreenshotCamera.targetTexture = rt;
  853.             ScreenshotCamera.Render();
  854.             //RenderNormalCamera();
  855.             ScreenshotCamera.targetTexture = rt;
  856.             Texture2D screenShot = new Texture2D(640, 720, TextureFormat.RGBA32, false);
  857.             RenderTexture.active = rt;
  858.             screenShot.ReadPixels(new Rect(0, 0, 640, 720), 0, 0);
  859.             ScreenshotCamera.targetTexture = null;
  860.             RenderTexture.active = null; // JC: added to avoid errors
  861.  
  862.             byte[] bytes = screenShot.EncodeToPNG();
  863.             string filename = Convert.ToBase64String(bytes);
  864.             SaveController.Instance.InsertBigScreenshot(SaveController.Instance.data.saveIndex, filename);
  865.             PromptWindow.Instance._async.allowSceneActivation = true;
  866.         }
  867.         catch (Exception ex)
  868.         {
  869.             PromptWindow.Instance._async.allowSceneActivation = true;
  870.         }
  871.     }
  872.  
  873.     private Vector3 GetScreenshotPosition()
  874.     {
  875.         return new Vector3((minX + maxX) / 2, 100, (minY + maxY) / 2);
  876.     }
  877.  
  878.     private float GetOrthographicSize(bool isBig = false)
  879.     {
  880.         ScreenshotCamera.transform.eulerAngles = new Vector3(ScreenshotCamera.transform.eulerAngles.x, 180, ScreenshotCamera.transform.eulerAngles.z);
  881.         float x = (maxX - minX) / 5f;
  882.         float y = (maxY - minY) / 5f;
  883.  
  884.         if (isBig)
  885.         {
  886.             x = x * 3;
  887.             y = y * 3;
  888.         }
  889.  
  890.         if (x < 0)
  891.             x = x * -1;
  892.         if (y < 0)
  893.             y = y * -1;
  894.  
  895.         x *= 1.5f;
  896.         y *= 1.5f;
  897.  
  898.         if (x > y)
  899.         {
  900.             if (isBig)
  901.                 ScreenshotCamera.transform.eulerAngles = new Vector3(ScreenshotCamera.transform.eulerAngles.x, -90, ScreenshotCamera.transform.eulerAngles.z);
  902.             return x;
  903.         }
  904.         else
  905.         {
  906.             if (!isBig)
  907.                 ScreenshotCamera.transform.eulerAngles = new Vector3(ScreenshotCamera.transform.eulerAngles.x, -90, ScreenshotCamera.transform.eulerAngles.z);
  908.             return y;
  909.         }
  910.     }
  911.  
  912.     bool firstPos = true;
  913.  
  914.  
  915.  
  916.     private List<Vector2> positionsForDelta = new List<Vector2>();
  917.     private List<float> speedForDelta = new List<float>();
  918.     private int tempPointIndex = 0;
  919.     public List<GameObject> selectedPoints = new List<GameObject>();
  920.     private bool SendLimit = false;
  921.     private string checkDate = "";
  922.     private int timeToDisconnect = 0;
  923.     private int _needToGetHz = 0;
  924.     private bool findedPositions =false;
  925.     private bool sended10Gz = false;
  926.     private int sendedDowngradeCount = 0;
  927.     private int sendedUpgradeCount = 0;
  928.     private bool showOriginalText = false;
  929.  
  930.  
  931.     private IEnumerator GetNMEA()
  932.     {
  933.         int tryToConnectCount = 0;
  934.         while (true)
  935.         {
  936.             if (IsConnected || SaveController.Instance.data.isInner)
  937.             {
  938.                 try
  939.                 {
  940. #if UNITY_ANDROID
  941.                     string nmeaString = gpsActivityJavaClass.CallStatic<string>("GetNMEA");
  942.                     SetDebugText(nmeaString);
  943.                     NMEAParser.Instance.ParseNMEA(nmeaString);
  944.                     string nmeaStringg = gpsActivityJavaClass.CallStatic<string>("GetNMEAMonent");
  945.                     NMEAParser.Instance.ParseMomentNMEA(nmeaStringg);
  946.  
  947.                     if(string.IsNullOrEmpty(nmeaString) && tryToConnectCount > 50)
  948.                     {
  949.                         if (!SaveController.Instance.data.isInner)
  950.                             UnpairBt();
  951.  
  952.                         if (SaveController.Instance.data.isInner)
  953.                         {
  954.                             gpsActivityJavaClass.CallStatic<string>("StartInnerGPS", LanguageManager.Instance.GetTextValue("InnerGPSEnable"), LanguageManager.Instance.GetTextValue("Yes"), LanguageManager.Instance.GetTextValue("No"));
  955.                         }
  956.                         tryToConnectCount = 0;
  957.                     }else if (string.IsNullOrEmpty(nmeaString))
  958.                     {
  959.                         tryToConnectCount++;
  960.                     }
  961.                     else
  962.                     {
  963.                         if(!showOriginalText && !IsOriginalDevice)
  964.                         {
  965.                             gpsActivityJavaClass.CallStatic<string>("ShowOriginalText", LanguageManager.Instance.GetTextValue("OriginalPopup"), LanguageManager.Instance.GetTextValue("OriginalPopupOk"));
  966.                             showOriginalText = true;
  967.                         }
  968.                         tryToConnectCount = 0;
  969.                     }
  970. #endif
  971. #if UNITY_STANDALONE
  972.                     WinBluetoothController.Instance.RequestNMEA();
  973. #endif
  974.                 }
  975.                 catch
  976.                 {
  977.  
  978.                 }
  979.             }else if(!IsConnected && tryToConnectCount > 50)
  980.             {
  981. #if UNITY_ANDROID
  982.                 string mac = PlayerPrefs.GetString("mac");
  983.                 string pin = PlayerPrefs.GetString("pin");
  984.                 string deviceName = PlayerPrefs.GetString("device");
  985.                 string test = "";
  986.                 if (!SaveController.Instance.data.isInner)
  987.                 {
  988.                     UnpairBt();
  989.                     test = gpsActivityJavaClass.CallStatic<string>("SetAdress", mac, pin, deviceName);
  990.                 }
  991.                 tryToConnectCount = 0;
  992. #endif
  993.             }
  994.            
  995.             yield return new WaitForSeconds(Gz);
  996.         }
  997.     }
  998.  
  999.     private IEnumerator GetPositions()
  1000.     {
  1001.         while (true)
  1002.         {
  1003.             if (ConstConfig.isInnerGPS)
  1004.             {
  1005.                 #if UNITY_ANDROID
  1006.                 string speedMmessage = gpsActivityJavaClass.CallStatic<string>("getSpeed");
  1007.                 if (speedMmessage != "Success" && SaveController.Instance.data.isInner)
  1008.                 {
  1009.                     loadingScreen.SetActive(false);
  1010.                     speed = float.Parse(speedMmessage);
  1011.                     speedText.text = Math.Round(speed, 0).ToString();
  1012.                 }
  1013. #endif
  1014.             }
  1015.             if (TryToConnectBt)
  1016.             {
  1017. #if UNITY_ANDROID
  1018.                 if (gpsActivityJavaClass != null)
  1019.                 {
  1020.                     string debug = gpsActivityJavaClass.CallStatic<string>("GetText");
  1021.                     debugText.text = debug;
  1022.                     string speedMessage = gpsActivityJavaClass.CallStatic<string>("getSpeed");
  1023.                     string getConnected = gpsActivityJavaClass.CallStatic<string>("getConnected");
  1024.                     //string LockHome = gpsActivityJavaClass.CallStatic<string>("LockHome");
  1025.                     if (getConnected != "true")
  1026.                     {
  1027.                         yield return null;
  1028.                     }
  1029.                     if(ConstConfig.isInnerGPS)
  1030.                     {
  1031.                         IsConnected = true;
  1032.                     }
  1033.                     if (speedMessage != "Success" || SaveController.Instance.data.isInner)
  1034.                     {
  1035.                         loadingScreen.SetActive(false);
  1036.                         speed = float.Parse(speedMessage);
  1037.                         if(speed > 0)
  1038.                         {
  1039.                             Debug.Log("Speed");
  1040.                         }
  1041.                         speedText.text = Math.Round(speed, 0).ToString();
  1042.                         if (sendedDowngradeCount <= 3)
  1043.                         {
  1044.                             SendDowngradeBT();
  1045.                             sendedDowngradeCount++;
  1046.                         }
  1047.                         else
  1048.                         {
  1049.                             if (PlayerPrefs.GetString("deviceId").Length != 10 && SattelitesPanel.Instance.IsAdded &&
  1050.                                 NMEAParser.Instance.FindedCoordinates && sendedUpgradeCount < 3 && !SaveController.Instance.data.isInner)
  1051.                             {
  1052.                                 gpsActivityJavaClass.CallStatic<string>("SendData",
  1053.                                     PlayerPrefs.GetString("deviceSpeed") + "\r\n");
  1054.                                 sendedUpgradeCount++;
  1055.                             }
  1056.                         }
  1057.                         if (!string.IsNullOrEmpty(PlayerPrefs.GetString("deviceSpeed")))
  1058.                         {
  1059.                             if (NMEAParser.Instance.FindedCoordinates && currentHdop <= 1.5f)
  1060.                             {
  1061.                                 loadingScreen.SetActive(false);
  1062.                             }
  1063.                             else if (!NMEAParser.Instance.FindedCoordinates && Math.Round(currentHdop, 1) == 0)
  1064.                             {
  1065.                                 loadingScreen.SetActive(true);
  1066.                                 LoadingText.color = Color.yellow;
  1067.                                 LoadingText.text = string.Format(LanguageManager.Instance.GetTextValue("SearchSat"),
  1068.                                     SattelitesPanel.Instance.SattelitesCount);
  1069.                             }
  1070.                             else if (currentHdop > 1.5f)
  1071.                             {
  1072.                                 LoadingText.color = Color.red;
  1073.                                 loadingScreen.SetActive(true);
  1074.                                 LoadingText.text = LanguageManager.Instance.GetTextValue("badSignal");
  1075.                             }
  1076.                         }
  1077.                         else
  1078.                         {
  1079.                             loadingScreen.SetActive(false);
  1080.                         }
  1081.  
  1082.                         IsConnected = true;
  1083.                     }
  1084.                     else
  1085.                     {
  1086.                         sendedUpgradeCount = 0;
  1087.                         sendedDowngradeCount = 0;
  1088.                         SattelitesPanel.Instance.SattelitesCount = 0;
  1089.                         SattelitesPanel.Instance.IsAdded = false;
  1090.                         NMEAParser.Instance.FindedCoordinates = false;
  1091.                         NMEAParser.Instance._lastNMEA = "";
  1092.                         SendLimit = false;
  1093.                         IsConnected = false;
  1094.                         LoadingText.color = Color.white;
  1095.                         loadingScreen.SetActive(true);
  1096.                         LoadingText.text = LanguageManager.Instance.GetTextValue("Search");
  1097.                         speedText.text = "0";
  1098.                         sattelitesCountText.text = LanguageManager.Instance.GetTextValue("SattelitesLbl") + "-";
  1099.                         hdop2Text.text = "HDOP: -";
  1100.                         currentHdop = 0;
  1101.                         string mac = PlayerPrefs.GetString("mac");
  1102.                         string pin = PlayerPrefs.GetString("pin");
  1103.                         string deviceName = PlayerPrefs.GetString("device");
  1104.                         string test = gpsActivityJavaClass.CallStatic<string>("SetAdress", mac, pin, deviceName);
  1105.  
  1106.                         //SceneManager.LoadScene(1);
  1107.                         yield return null;
  1108.                     }
  1109.  
  1110.                 }
  1111.                 else
  1112.                 {
  1113.                     AndroidJNI.AttachCurrentThread();
  1114.                     gpsActivityJavaClass = new AndroidJavaClass("com.velestor.tractor.GPSTest");
  1115.                 }
  1116. #elif !UNITY_EDITOR && UNITY_WSA_10_0
  1117.             try
  1118.             {
  1119.                 if (!isDemo)
  1120.                 {
  1121.                     float speedMessage = uBluetooth.GetSpeed();
  1122.                     if (uBluetooth.isConnected || ConstConfig.isInnerGPS)
  1123.                     {
  1124.                        
  1125.                         speed = speedMessage;
  1126.                         speedText.text = Math.Round(speed, 0).ToString();
  1127.                         if (!string.IsNullOrEmpty(PlayerPrefs.GetString("deviceSpeed")))
  1128.                         {
  1129.                             if (NMEAParser.Instance.FindedCoordinates && currentHdop <= 1.5f || ConstConfig.isInnerGPS)
  1130.                             {
  1131.                                 loadingScreen.SetActive(false);
  1132.                             }
  1133.                             else if (!NMEAParser.Instance.FindedCoordinates && Math.Round(currentHdop, 1) == 0)
  1134.                             {
  1135.                                 loadingScreen.SetActive(true);
  1136.                                 LoadingText.color = Color.yellow;
  1137.                                 LoadingText.text = string.Format(LanguageManager.Instance.GetTextValue("SearchSat"),
  1138.                                     SattelitesPanel.Instance.SattelitesCount);
  1139.                             }
  1140.                             else if (currentHdop > 1.5f)
  1141.                             {
  1142.                                 LoadingText.color = Color.red;
  1143.                                 loadingScreen.SetActive(true);
  1144.                                 LoadingText.text = LanguageManager.Instance.GetTextValue("badSignal");
  1145.                             }
  1146.                         }
  1147.                         else
  1148.                         {
  1149.                             loadingScreen.SetActive(false);
  1150.                         }
  1151.                         IsConnected = true;
  1152.                         try
  1153.                         {
  1154.                                 if (!ConstConfig.isInnerGPS)
  1155.                                 {
  1156.                                     string nmeaString = uBluetooth.GetMNEAString();
  1157.                                     NMEAParser.Instance.ParseNMEA(nmeaString);
  1158.                                 }
  1159.                         }
  1160.                         catch
  1161.                         {
  1162.  
  1163.                         }
  1164.  
  1165.                         if (sendedDowngradeCount <= 3 && !ConstConfig.isInnerGPS)
  1166.                         {
  1167.                             SendDowngradeBT();
  1168.                             sendedDowngradeCount++;
  1169.                         }
  1170.                         else
  1171.                         {
  1172.                             if (SattelitesPanel.Instance.IsAdded && sendedUpgradeCount < 3)
  1173.                             {
  1174.                                     string toSend = PlayerPrefs.GetString("deviceSpeed") + "\r\n";
  1175.                                     uBluetooth.Send(toSend);
  1176.                                     sendedUpgradeCount++;
  1177.                             }
  1178.                         }
  1179.  
  1180.  
  1181.                     }
  1182.                     else
  1183.                     {
  1184.                         sendedUpgradeCount = 0;
  1185.                         sendedDowngradeCount = 0;
  1186.                         SattelitesPanel.Instance.SattelitesCount = 0;
  1187.                         SattelitesPanel.Instance.IsAdded = false;
  1188.                         NMEAParser.Instance.FindedCoordinates = false;
  1189.                         NMEAParser.Instance._lastNMEA = "";
  1190.                         SendLimit = false;
  1191.                         IsConnected = false;
  1192.                         LoadingText.color = Color.white;
  1193.                         loadingScreen.SetActive(true);
  1194.                         LoadingText.text = LanguageManager.Instance.GetTextValue("Search");
  1195.                         //speedText.text = "Скорость не доступна. Соеденение";
  1196.                         speedText.text = "0";
  1197.                         sattelitesCountText.text = LanguageManager.Instance.GetTextValue("SattelitesLbl") + "-";
  1198.                        
  1199.                     }
  1200.                    
  1201.                 }
  1202.                 else
  1203.                 {
  1204.                     if (uBluetooth.isConnected && SattelitesPanel.Instance.IsAdded && NMEAParser.Instance.FindedCoordinates)
  1205.                     {
  1206.                         if (toSendTime >= 50)
  1207.                         {
  1208.                             string toSend = PlayerPrefs.GetString("deviceSpeed") + "\r\n";
  1209.                             uBluetooth.Send(toSend);
  1210.                             toSendTime = 0;
  1211.                         }
  1212.                         GenerateSendData();
  1213.                         toSendTime++;
  1214.                     }
  1215.                 }
  1216.             }
  1217.             catch (Exception ex)
  1218.             {
  1219.  
  1220.             }
  1221.  
  1222. #elif UNITY_STANDALONE
  1223.                 WinBluetoothController.Instance.GetConnectionState();
  1224. #endif
  1225.  
  1226.             }
  1227.  
  1228.             yield return new WaitForSeconds(1);
  1229.         }
  1230.     }
  1231.  
  1232.     public void SetSpeed(float speed)
  1233.     {
  1234.         if (!ConstConfig.isInnerGPS)
  1235.         {
  1236.             this.speed = speed;
  1237.             speedText.text = Math.Round(speed, 0).ToString();
  1238.         }
  1239.     }
  1240.     public void SetConnectionState(bool state)
  1241.     {
  1242.         if (SaveController.Instance.data.debugFileName != "-")
  1243.             return;
  1244.  
  1245.         if (state)
  1246.         {
  1247.             loadingScreen.SetActive(false);
  1248.             //speed = float.Parse(speedMessage);
  1249.             //speedText.text = Math.Round(speed, 0).ToString();
  1250.             if (sendedDowngradeCount <= 3)
  1251.             {
  1252.                 SendDowngradeBT();
  1253.                 sendedDowngradeCount++;
  1254.             }
  1255.             else
  1256.             {
  1257.                 if (PlayerPrefs.GetString("deviceId").Length != 10 && SattelitesPanel.Instance.IsAdded &&
  1258.                     NMEAParser.Instance.FindedCoordinates && sendedUpgradeCount < 3)
  1259.                 {
  1260.                     WinBluetoothController.Instance.Send(PlayerPrefs.GetString("deviceSpeed") + "\r\n");
  1261.                     sendedUpgradeCount++;
  1262.                 }
  1263.             }
  1264.             if (!string.IsNullOrEmpty(PlayerPrefs.GetString("deviceSpeed")))
  1265.             {
  1266.                 if (NMEAParser.Instance.FindedCoordinates && currentHdop <= 1.5f)
  1267.                 {
  1268.                     loadingScreen.SetActive(false);
  1269.                 }
  1270.                 else if (!NMEAParser.Instance.FindedCoordinates && Math.Round(currentHdop, 1) == 0)
  1271.                 {
  1272.                     loadingScreen.SetActive(true);
  1273.                     LoadingText.color = Color.yellow;
  1274.                     LoadingText.text = string.Format(LanguageManager.Instance.GetTextValue("SearchSat"),
  1275.                         SattelitesPanel.Instance.SattelitesCount);
  1276.                 }
  1277.                 else if (currentHdop > 1.5f)
  1278.                 {
  1279.                     LoadingText.color = Color.red;
  1280.                     loadingScreen.SetActive(true);
  1281.                     LoadingText.text = LanguageManager.Instance.GetTextValue("badSignal");
  1282.                 }
  1283.             }
  1284.             else
  1285.             {
  1286.                 loadingScreen.SetActive(false);
  1287.             }
  1288.  
  1289.             IsConnected = true;
  1290.         }
  1291.         else
  1292.         {
  1293.             sendedUpgradeCount = 0;
  1294.             sendedDowngradeCount = 0;
  1295.             SattelitesPanel.Instance.SattelitesCount = 0;
  1296.             SattelitesPanel.Instance.IsAdded = false;
  1297.             NMEAParser.Instance.FindedCoordinates = false;
  1298.             NMEAParser.Instance._lastNMEA = "";
  1299.             SendLimit = false;
  1300.             IsConnected = false;
  1301.             LoadingText.color = Color.white;
  1302.             loadingScreen.SetActive(true);
  1303.             LoadingText.text = LanguageManager.Instance.GetTextValue("Search");
  1304.             speedText.text = "0";
  1305.             sattelitesCountText.text = LanguageManager.Instance.GetTextValue("SattelitesLbl") + "-";
  1306.             hdop2Text.text = "HDOP: -";
  1307.             currentHdop = 0;
  1308.         }
  1309.  
  1310.     }
  1311.  
  1312.     public float TimeToUpdate = 1;
  1313.     public bool NormalHDOP = false;
  1314.  
  1315.     public void SetSattelitesCount(int SattelitesCount)
  1316.     {
  1317.         if(!SaveController.Instance.data.isAccelerator)
  1318.             sattelitesCountText.text = LanguageManager.Instance.GetTextValue("SattelitesLbl") + SattelitesCount.ToString();
  1319.     }
  1320.  
  1321.     private float currentHdop = 0;
  1322.  
  1323.     public void SetHdop(float hdop)
  1324.     {
  1325.         currentHdop = hdop;
  1326.         if (hdop <= 0 || hdop > 1.5f)
  1327.         {
  1328.             NormalHDOP = false;
  1329.         }
  1330.         else
  1331.         {
  1332.             NormalHDOP = true;
  1333.         }
  1334.  
  1335.         if (Math.Round(hdop, 1) != 0)
  1336.         {
  1337.             hdop2Text.text = "HDOP: " + Math.Round(hdop, 1);
  1338.         }
  1339.         else
  1340.         {
  1341.             hdop2Text.text = "HDOP: -";
  1342.         }
  1343.     }
  1344.  
  1345.     private int pointsCount = 0;
  1346.     private int pointsCountt = 0;
  1347.     private float time = 0;
  1348.     private int toSendTime = 0;
  1349.  
  1350.     private IEnumerator GetPositionsFromBluetooth()
  1351.     {
  1352.         while (true)
  1353.         {
  1354.             try
  1355.             {
  1356.                 if (IsConnected)
  1357.                 {
  1358. #if UNITY_ANDROID
  1359.                     if (gpsActivityJavaClass != null)
  1360.                     {
  1361.                         AndroidJavaObject ajObject = gpsActivityJavaClass.CallStatic<AndroidJavaObject>("getLocation");
  1362.                         if (ajObject != null)
  1363.                         {
  1364.                             double lat = ajObject.Get<double>("Latitude");
  1365.                             double lon = ajObject.Get<double>("Longitude");
  1366.                             double ac = ajObject.Get<float>("Quality");
  1367.                             altitude = float.Parse(gpsActivityJavaClass.CallStatic<string>("GetAltitude"));
  1368.                             Vector2 newPos = new Vector2(KMLController.lonToX((float) lon) * 50,
  1369.                                 KMLController.latToZ((float) lat) * 60f);
  1370.  
  1371.                             if (lat != 0 && lon != 0)
  1372.                             {
  1373.                                 if (ConstConfig.isInnerGPS)
  1374.                                 {
  1375.                                     string speedMmessage = gpsActivityJavaClass.CallStatic<string>("getSpeed");
  1376.                                     if (speedMmessage != "Success" && SaveController.Instance.data.isInner)
  1377.                                     {
  1378.                                         loadingScreen.SetActive(false);
  1379.                                         speed = float.Parse(speedMmessage);
  1380.                                         speedText.text = Math.Round(speed, 0).ToString();
  1381.                                     }
  1382.                                 }
  1383.                                 findedPositions = true;
  1384.                                 if (!SendLimit)
  1385.                                 {
  1386.                                     if (gpsActivityJavaClass != null && PlayerPrefs.GetString("deviceId").Length != 10 && SattelitesPanel.Instance.IsAdded && NMEAParser.Instance.FindedCoordinates)
  1387.                                     {
  1388.                                         gpsActivityJavaClass.CallStatic<string>("SendData",
  1389.                                             PlayerPrefs.GetString("deviceSpeed") + "\r\n");
  1390.                                         SendLimit = true;
  1391.                                     }
  1392.                                 }
  1393.                                 if (firstPosition == Vector2.zero)
  1394.                                 {
  1395.                                     if (SaveController.Instance.data.startingPos != Vector2.zero)
  1396.                                     {
  1397.                                         firstPosition = SaveController.Instance.data.startingPos;
  1398.                                     }
  1399.                                     else
  1400.                                     {
  1401.                                         SaveController.Instance.data.startingPos = newPos;
  1402.                                         firstPosition = newPos;
  1403.                                         SaveController.Instance.InsertFristPosition(firstPosition);
  1404.                                     }
  1405.                                 }
  1406.  
  1407.                                 var point = Instantiate(NextPoint);
  1408.                                 point.gameObject.transform.SetParent(parent.transform, false);
  1409.                                 point.transform.localRotation = NextPoint.gameObject.transform.localRotation;
  1410.                                 point.transform.localPosition = new Vector3(firstPosition.x - newPos.x,
  1411.                                     NextPoint.gameObject.transform.localPosition.y, firstPosition.y - newPos.y);
  1412.                                 //Debug.Log("xpn: " + (firstPosition.x - newPos.x) + "  ynp: " + (firstPosition.y - newPos.y));
  1413.  
  1414.                                 if (isContinue && !setPositionFromSave)
  1415.                                 {
  1416.                                     transform.position = new Vector3(point.transform.position.x, transform.position.y,
  1417.                                         point.transform.position.z);
  1418.                                     setPositionFromSave = true;
  1419.                                 }
  1420.  
  1421.                                 if (speed >= speedLimit) // && speed > 0.01f)
  1422.                                 {
  1423.                                     Points.Add(point);
  1424.                                     currentTime = 0;
  1425.  
  1426.                                     pointsCount++;
  1427.  
  1428.                                     if (pointsCount >= pointsDealey)
  1429.                                     {
  1430.                                         point.transform.position = CreateSector();
  1431.  
  1432.                                         if (selectedPoints.Count >= sectorsDealey)
  1433.                                         {
  1434.                                             bool movingState = isMoving;
  1435.                                             if (!isMoving)
  1436.                                             {
  1437.                                                 transform.LookAt(point.transform);
  1438.                                             }
  1439.  
  1440.                                             GameObject prevSector = NextPoint;
  1441.                                             GameObject newPoint = GetFinestPosition();
  1442.                                             prevSector.GetComponent<MeshRenderer>().material = PassedPointMaterial;
  1443.  
  1444.                                             if (movedCount > 2 && CheckWorkType.Instance.typeId == 8)
  1445.                                             {
  1446.  
  1447.                                                 float widthM = (float) SaveController.Instance.data.widthM;
  1448.                                                 float widthSM = (float) SaveController.Instance.data.widthSM / 100;
  1449.                                                 float delt = (widthM + widthSM) / 2;
  1450.  
  1451.                                                 double xM =
  1452.                                                     KMLController.xToLon(
  1453.                                                     (-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f))
  1454.                                                          .x +
  1455.                                                      firstPosition.x) / 50);
  1456.                                                 double yM =
  1457.                                                     KMLController.zToLat(
  1458.                                                     (-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f))
  1459.                                                          .z +
  1460.                                                      firstPosition.y) / 60);
  1461.                                                 gpxString += xM + "," + yM + "," + Math.Round(speed, 2) + "," + altitude +
  1462.                                                              "," + currentDate +
  1463.                                                              " \r\n";
  1464.  
  1465.                                             }
  1466.  
  1467.                                             if (MainRightPanel.Instance.Paint)
  1468.                                             {
  1469.                                                 if (needToAddPosition)
  1470.                                                 {
  1471.                                                     float delt = (SaveController.Instance.data.widthM +
  1472.                                                                   SaveController.Instance.data.widthSM / 100) / 2;
  1473.                                                     double xR =
  1474.                                                         KMLController.xToLon(
  1475.                                                         (-(arrowTransform.position +
  1476.                                                            arrowTransform.up * (delt * 6.278353f)).x +
  1477.                                                          firstPosition.x) / 50);
  1478.                                                     double yR =
  1479.                                                         KMLController.zToLat(
  1480.                                                         (-(arrowTransform.position +
  1481.                                                            arrowTransform.up * (delt * 6.278353f)).z +
  1482.                                                          firstPosition.y) / 60);
  1483.                                                     double xL =
  1484.                                                         KMLController.xToLon(
  1485.                                                         (-(arrowTransform.position +
  1486.                                                            (-arrowTransform.up * (delt * 6.278353f))).x +
  1487.                                                          firstPosition.x) / 50);
  1488.                                                     double yL =
  1489.                                                         KMLController.zToLat(
  1490.                                                         (-(arrowTransform.position +
  1491.                                                            (-arrowTransform.up * (delt * 6.278353f))).z +
  1492.                                                          firstPosition.y) / 60);
  1493.                                                     if (CheckWorkType.Instance.typeId == 8)
  1494.                                                     {
  1495.                                                         if (!SquareController.Instance.newMode ||
  1496.                                                             (SquareController.Instance.newMode &&
  1497.                                                              SquareController.InSquare(
  1498.                                                                  SquareController.Instance.linePositions.ToArray(),
  1499.                                                                  transform.position)))
  1500.                                                         {
  1501.                                                             forGoogleString += lat + "," + lon + "|";
  1502.                                                             forKMLLeft += xL + "," + yL + "," + altitude + " \r\n";
  1503.                                                             kmlRightList.Add(xR + "," + yR + "," + altitude + " \r\n");
  1504.                                                             forKML += lat + "," + lon + "," + altitude + " \r\n";
  1505.                                                         }
  1506.                                                         double xM =
  1507.                                                             KMLController.xToLon(
  1508.                                                             (-(arrowTransform.position +
  1509.                                                                arrowTransform.up * (delt * 6.278353f)).x +
  1510.                                                              firstPosition.x) / 50);
  1511.                                                         double yM =
  1512.                                                             KMLController.zToLat(
  1513.                                                             (-(arrowTransform.position +
  1514.                                                                arrowTransform.up * (delt * 6.278353f)).z +
  1515.                                                              firstPosition.y) / 60);
  1516.                                                         //gpxString += xM + "," + yM + "," + Math.Round(speed, 2) + ","+altitude+","+currentDate+" \r\n";
  1517.                                                         minSpeed = SpeedWindow.Instance.CurrentMinSpeed;
  1518.                                                         maxSpeed = SpeedWindow.Instance.CurrentMaxSpeed;
  1519.                                                     }
  1520.                                                     else
  1521.                                                     {
  1522.                                                         if (!SquareController.Instance.newMode ||
  1523.                                                             (SquareController.Instance.newMode &&
  1524.                                                              SquareController.InSquare(
  1525.                                                                  SquareController.Instance.linePositions.ToArray(),
  1526.                                                                  transform.position)))
  1527.                                                         {
  1528.                                                             forGoogleString += lat + "," + lon + "|";
  1529.                                                             forKMLLeft += xL + "," + yL + ",0 \r\n";
  1530.                                                             kmlRightList.Add(xR + "," + yR + ",0 \r\n");
  1531.                                                             forKML += lat + "," + lon + ",0 \r\n";
  1532.                                                         }
  1533.                                                     }
  1534.                                                     PlayerPrefs.SetString(
  1535.                                                         "map" + SaveController.Instance.data.saveIndex, forGoogleString);
  1536.                                                     needToAddPosition = false;
  1537.                                                 }
  1538.                                                 else
  1539.                                                 {
  1540.                                                     needToAddPosition = true;
  1541.                                                 }
  1542.                                                 speeds.Add(speed);
  1543.                                             }
  1544.                                             if (SquareController.Instance.isTracked)
  1545.                                             {
  1546.                                                 if (needToAddSquare)
  1547.                                                 {
  1548.                                                     if (CheckWorkType.Instance.typeId == 8)
  1549.                                                     {
  1550.                                                         kmlSquare += lon + "," + lat + "," + altitude + " \r\n";
  1551.                                                     }
  1552.                                                     else
  1553.                                                     {
  1554.                                                         kmlSquare += lon + "," + lat + ",0 \r\n";
  1555.                                                     }
  1556.                                                     if (string.IsNullOrEmpty(kmlStartSquare))
  1557.                                                     {
  1558.                                                         kmlStartSquare = kmlSquare;
  1559.                                                     }
  1560.                                                     needToAddSquare = false;
  1561.                                                 }
  1562.                                                 else
  1563.                                                 {
  1564.                                                     needToAddSquare = true;
  1565.                                                 }
  1566.                                             }
  1567.  
  1568.                                             if (newPoint != null)
  1569.                                             {
  1570.                                                 bool needToRotate = false;
  1571.                                                 NextPoint = newPoint;
  1572.                                                 if (NextPoint.transform.position != prevSector.transform.position)
  1573.                                                 {
  1574.                                                     prevSector.transform.LookAt(NextPoint.transform);
  1575.                                                     NextPoint.transform.rotation = prevSector.transform.rotation;
  1576.                                                     needToRotate = true;
  1577.                                                 }
  1578.  
  1579.                                                 int i = selectedPoints.IndexOf(NextPoint);
  1580.                                                 for (int k = i; k >= 0; k--)
  1581.                                                 {
  1582.                                                     selectedPoints.RemoveAt(k);
  1583.                                                 }
  1584.  
  1585.                                                 if (isMoving)
  1586.                                                 {
  1587.                                                     if (trailer[0].transform.parent != null && ponitCount == 3)
  1588.                                                     {
  1589.  
  1590.  
  1591.                                                         //SetZOffset(normalOffset);
  1592.  
  1593.                                                         StartCoroutine(SmoothChangeJoint(normalOffset + 1,
  1594.                                                             Gz *
  1595.                                                             ((pointsDealey) * (sectorsDealey - selectedPoints.Count + 1)) *
  1596.                                                             2)); // SetZOffset(normalOffset);
  1597.  
  1598.                                                         ponitCount = 0;
  1599.  
  1600.                                                         transform.LookAt(NextPoint.transform);
  1601.                                                         transform.LookAt(NextPoint.transform);
  1602.                                                         transform.LookAt(NextPoint.transform);
  1603.                                                         transform.LookAt(NextPoint.transform);
  1604.                                                         foreach (GameObject go in trailer)
  1605.                                                             go.transform.SetParent(null);
  1606.  
  1607.  
  1608.                                                         MainRightPanel.Instance.ContinueDraw();
  1609.                                                         isBack = false;
  1610.                                                     }
  1611.                                                     else if (trailer[0].transform.parent != null && ponitCount < 3)
  1612.                                                     {
  1613.                                                         //transform.LookAt(NextPoint.transform);
  1614.                                                         //transform.position = NextPoint.transform.position;
  1615.                                                         ponitCount++;
  1616.                                                     }
  1617.  
  1618.                                                 }
  1619.  
  1620.                                                 Vector3 heading = NextPoint.transform.position - transform.position;
  1621.                                                 float dot = Vector3.Dot(heading, transform.forward);
  1622.                                                 if (dot < -1 && trailer[0].transform.parent == null)
  1623.                                                 {
  1624.                                                     /* Debug.Log("Dot: " + dot);
  1625.                                                      StopCoroutine("LookToEuler");
  1626.                                                      MainRightPanel.Instance.EndDraw();
  1627.    
  1628.                                                      foreach (GameObject go in trailer)
  1629.                                                      {
  1630.                                                          go.transform.SetParent(transform);
  1631.                                                          go.transform.localEulerAngles = Vector3.zero;
  1632.    
  1633.                                                      }
  1634.                                                      SetZOffset(0, 0);
  1635.                                                      transform.LookAt(NextPoint.transform);
  1636.                                                      */
  1637.                                                 }
  1638.  
  1639.                                                 isMoving = true;
  1640.  
  1641.                                                 CheckForMinMax(new Vector2(NextPoint.transform.position.x,
  1642.                                                     NextPoint.transform.position.z));
  1643.  
  1644.                                                 if (!isBack)
  1645.                                                 {
  1646.                                                     float angle = AngleSigned(transform.forward,
  1647.                                                         NextPoint.transform.position - transform.position, transform.up);
  1648.                                                     if (movCor != null)
  1649.                                                     {
  1650.                                                         StopCoroutine(movCor);
  1651.                                                     }
  1652.  
  1653.                                                         ChangeSppedLimit();
  1654.  
  1655.                                                     movCor =
  1656.                                                         StartCoroutine(MoveToPosition(transform, prevSector.transform,
  1657.                                                             NextPoint.transform.position,
  1658.                                                             Gz *
  1659.                                                             (pointsDealey * (sectorsDealey - selectedPoints.Count + 1))));
  1660.  
  1661.                                                     string androidDate =
  1662.                                                         gpsActivityJavaClass.CallStatic<String>("GetDate");
  1663.                                                     if (string.IsNullOrEmpty(startingDate) &&
  1664.                                                         !string.IsNullOrEmpty(androidDate))
  1665.                                                     {
  1666.                                                         string[] dd = androidDate.Split(new[] {' '},
  1667.                                                             StringSplitOptions.RemoveEmptyEntries);
  1668.                                                         string d = string.Format("{0}/{1}/{2} {3}:{4}:{5}",
  1669.                                                             dd[0].Substring(0, 2), dd[0].Substring(2, 2),
  1670.                                                             dd[0].Substring(4, 2),
  1671.                                                             dd[1].Substring(0, 2), dd[1].Substring(2, 2),
  1672.                                                             dd[1].Substring(4, 2));
  1673.                                                         startingDate = d;
  1674.                                                         PlayerPrefs.SetString(
  1675.                                                             "date" + SaveController.Instance.data.saveIndex,
  1676.                                                             startingDate);
  1677.                                                     }
  1678.                                                     else
  1679.                                                     {
  1680.                                                         string[] dd = androidDate.Split(new[] {' '},
  1681.                                                             StringSplitOptions.RemoveEmptyEntries);
  1682.                                                         string d = string.Format("{0}/{1}/{2} {3}:{4}:{5}",
  1683.                                                             dd[0].Substring(0, 2), dd[0].Substring(2, 2),
  1684.                                                             dd[0].Substring(4, 2),
  1685.                                                             dd[1].Substring(0, 2), dd[1].Substring(2, 2),
  1686.                                                             dd[1].Substring(4, 2));
  1687.                                                         currentDate = d;
  1688.                                                         if (currentDate.EndsWith("18"))
  1689.                                                         {
  1690.                                                             //PlayerPrefs.SetInt("NeedUpdate", 1);
  1691.                                                         }
  1692.                                                     }
  1693.  
  1694.                                                     if (firstPos)
  1695.                                                     {
  1696.                                                         SetZOffset(normalOffset);
  1697.                                                         foreach (GameObject go in trailer)
  1698.                                                             go.transform.SetParent(null);
  1699.  
  1700.                                                         SquareController.Instance.CheckAfterMove();
  1701.                                                         CurveController.Instance.CheckAfterMove();
  1702.                                                         ParalelsController.Instance.CheckAfterMove();
  1703.  
  1704.                                                     }
  1705.                                                     firstPos = false;
  1706.                                                     if (needToRotate)
  1707.                                                     {
  1708.                                                         if (rotCor != null)
  1709.                                                             StopCoroutine(rotCor);
  1710.  
  1711.                                                         if (dot > -4)
  1712.                                                         {
  1713.                                                             rotCor =
  1714.                                                                 StartCoroutine(LookToEuler(
  1715.                                                                     NextPoint.transform.rotation,
  1716.                                                                     Gz *
  1717.                                                                     ((pointsDealey) *
  1718.                                                                      (sectorsDealey - selectedPoints.Count + 1))));
  1719.                                                             if (trailer[0].transform.parent != null)
  1720.                                                             {
  1721.                                                                 trailer[0].transform.SetParent(transform);
  1722.                                                                 trailer[0].transform.localEulerAngles = Vector3.zero;
  1723.                                                             }
  1724.                                                         }
  1725.                                                         else
  1726.                                                         {
  1727.                                                             if (trailer[0].transform.parent == null)
  1728.                                                             {
  1729.                                                                 if (rotCor != null)
  1730.                                                                     StopCoroutine(rotCor);
  1731.                                                                 StopCoroutine(movCor);
  1732.                                                                 MainRightPanel.Instance.EndDraw();
  1733.                                                                 foreach (GameObject go in trailer)
  1734.                                                                 {
  1735.  
  1736.                                                                     go.transform.SetParent(transform);
  1737.                                                                     go.transform.localEulerAngles = Vector3.zero;
  1738.                                                                     StopCoroutine("SmoothChangeJoint");
  1739.                                                                     //SetZOffset(0, 0);
  1740.                                                                     startingRotate = trackedPoint.rotation;
  1741.                                                                     StartCoroutine(SmoothChangeJoint(0,
  1742.                                                                             Gz *
  1743.                                                                             ((pointsDealey) *
  1744.                                                                              (sectorsDealey - selectedPoints.Count + 1))));
  1745.                                                                         // SetZOffset(normalOffset);//SetZOffset(0, 0);
  1746.                                                                     ponitCount = 0;
  1747.                                                                     //transform.LookAt(NextPoint.transform);
  1748.                                                                 }
  1749.                                                                 isBack = true;
  1750.                                                             }
  1751.                                                         }
  1752.                                                     }
  1753.                                                 }
  1754.                                                 else
  1755.                                                 {
  1756.                                                     StopCoroutine(movCor);
  1757.                                                 }
  1758.  
  1759.                                                 /*else
  1760.                                                 {
  1761.    
  1762.                                                 }*/
  1763.  
  1764.                                                 Points.Clear();
  1765.  
  1766.                                             }
  1767.  
  1768.  
  1769.                                         }
  1770.  
  1771.  
  1772.  
  1773.                                         pointsCount = 0;
  1774.                                     }
  1775.                                     else if (!isMoving && selectedPoints.Count == 1 &&
  1776.                                              point.transform.position != transform.position)
  1777.                                     {
  1778.  
  1779.                                     }
  1780.                                     if (Points.Count >= 100)
  1781.                                     {
  1782.                                         Points.RemoveRange(0, 50);
  1783.                                     }
  1784.  
  1785.                                 }
  1786.                                 else
  1787.                                 {
  1788.                                     StopCoroutine("MoveToPosition");
  1789.                                 }
  1790.  
  1791.  
  1792.                             }
  1793.                             if (sendCount == 5)
  1794.                             {
  1795.                                 GenerateSendData();
  1796.                                 sendCount = 0;
  1797.                             }
  1798.                             sendCount++;
  1799.                         }
  1800.                     }
  1801. #elif !UNITY_EDITOR && UNITY_WSA_10_0 || UNITY_STANDALONE
  1802.                 PositionModel ajObject;
  1803.  
  1804. #if UNITY_WSA_10_0
  1805.                 ajObject = uBluetooth.GetPosition();
  1806.                 altitude = uBluetooth.altitude;
  1807.                     if(ConstConfig.isInnerGPS)
  1808.                     {
  1809.                         hdop2Text.text = "HDOP: " + Math.Round(ajObject.hdop, 1);
  1810.                     }
  1811. #else
  1812.                     ajObject = NMEAParser.Instance.position;
  1813.                     altitude = NMEAParser.Instance.altitude;
  1814. #endif
  1815.                 if (ajObject != null)
  1816.                 {
  1817.                     double lat = ajObject.lat;
  1818.                     double lon = ajObject.lon;
  1819.  
  1820.                     Vector2 newPos = new Vector2(KMLController.lonToX(lon) * 50, KMLController.latToZ(lat) * 60);
  1821.  
  1822.                         if (lat != 0 && lon != 0)
  1823.                         {
  1824.                             if (firstPosition == Vector2.zero)
  1825.                             {
  1826.                                 if (SaveController.Instance.data.startingPos != Vector2.zero)
  1827.                                 {
  1828.                                     firstPosition = SaveController.Instance.data.startingPos;
  1829.                                 }
  1830.                                 else
  1831.                                 {
  1832.                                     SaveController.Instance.data.startingPos = newPos;
  1833.                                     firstPosition = newPos;
  1834.                                     SaveController.Instance.InsertFristPosition(firstPosition);
  1835.                                 }
  1836.                             }
  1837.  
  1838.                             var point = Instantiate(NextPoint);
  1839.                             point.gameObject.transform.SetParent(parent.transform, false);
  1840.                             point.transform.localRotation = NextPoint.gameObject.transform.localRotation;
  1841.                             point.transform.localPosition = new Vector3(firstPosition.x - newPos.x, NextPoint.gameObject.transform.localPosition.y, firstPosition.y - newPos.y);
  1842.                             //Debug.Log("xpn: " + (firstPosition.x - newPos.x) + "  ynp: " + (firstPosition.y - newPos.y));
  1843.                             if (isContinue && !setPositionFromSave)
  1844.                             {
  1845.                                 transform.position = new Vector3(point.transform.position.x, transform.position.y, point.transform.position.z);
  1846.                                 setPositionFromSave = true;
  1847.                             }
  1848.  
  1849.                             if (speed > speedLimit && !ConstConfig.isInnerGPS)// && speed > 0.01f)
  1850.                             {
  1851.                                 Points.Add(point);
  1852.                                 currentTime = 0;
  1853.  
  1854.                                 pointsCount++;
  1855.  
  1856.                                 if (pointsCount >= pointsDealey)
  1857.                                 {
  1858.                                     point.transform.position = CreateSector();
  1859.  
  1860.                                     if (selectedPoints.Count >= sectorsDealey)
  1861.                                     {
  1862.                                         bool movingState = isMoving;
  1863.                                         if (!isMoving)
  1864.                                         {
  1865.                                             transform.LookAt(point.transform);
  1866.                                         }
  1867.  
  1868.                                         GameObject prevSector = NextPoint;
  1869.                                         GameObject newPoint = GetFinestPosition();
  1870.                                         prevSector.GetComponent<MeshRenderer>().material = PassedPointMaterial;
  1871.                                         if (movedCount > 2 && CheckWorkType.Instance.typeId == 8)
  1872.                                         {
  1873.  
  1874.                                             float widthM = (float)SaveController.Instance.data.widthM;
  1875.                                             float widthSM = (float)SaveController.Instance.data.widthSM / 100;
  1876.                                             float delt = (widthM + widthSM) / 2;
  1877.  
  1878.                                             double xM =
  1879.                                                 KMLController.xToLon(
  1880.                                                 (-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).x +
  1881.                                                  firstPosition.x) / 50);
  1882.                                             double yM =
  1883.                                                 KMLController.zToLat(
  1884.                                                 (-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).z +
  1885.                                                  firstPosition.y) / 60);
  1886.                                             gpxString += xM + "," + yM + "," + Math.Round(speed, 2) + "," + altitude + "," + currentDate +
  1887.                                                          " \r\n";
  1888.  
  1889.                                         }
  1890.  
  1891.                                         if (MainRightPanel.Instance.Paint)
  1892.                                         {
  1893.                                             if (needToAddPosition)
  1894.                                             {
  1895.                                                 float delt = (SaveController.Instance.data.widthM + SaveController.Instance.data.widthSM / 100) / 2;
  1896.                                                 double xR = KMLController.xToLon((-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).x + firstPosition.x) / 50);
  1897.                                                 double yR = KMLController.zToLat((-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).z + firstPosition.y) / 60);
  1898.                                                 double xL = KMLController.xToLon((-(arrowTransform.position + (-arrowTransform.up * (delt * 6.278353f))).x + firstPosition.x) / 50);
  1899.                                                 double yL = KMLController.zToLat((-(arrowTransform.position + (-arrowTransform.up * (delt * 6.278353f))).z + firstPosition.y) / 60);
  1900.                                                 if (CheckWorkType.Instance.typeId == 8)
  1901.                                                 {
  1902.                                                     if (!SquareController.Instance.newMode ||
  1903.                                                                             (SquareController.Instance.newMode &&
  1904.                                                                              SquareController.InSquare(SquareController.Instance.linePositions.ToArray(),
  1905.                                                                                  transform.position)))
  1906.                                                     {
  1907.                                                         forGoogleString += lat + "," + lon + "|";
  1908.                                                         forKMLLeft += xL + "," + yL + "," + altitude + " \r\n";
  1909.                                                         kmlRightList.Add(xR + "," + yR + "," + altitude + " \r\n");
  1910.                                                         forKML += lat + "," + lon + "," + altitude + " \r\n";
  1911.                                                     }
  1912.                                                     double xM = KMLController.xToLon((-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).x + firstPosition.x) / 50);
  1913.                                                     double yM = KMLController.zToLat((-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).z + firstPosition.y) / 60);
  1914.                                                     //gpxString += xM + "," + yM + "," + Math.Round(speed, 2) + ","+altitude+","+currentDate+" \r\n";
  1915.                                                     minSpeed = SpeedWindow.Instance.CurrentMinSpeed;
  1916.                                                     maxSpeed = SpeedWindow.Instance.CurrentMaxSpeed;
  1917.  
  1918.                                                 }
  1919.                                                 else
  1920.                                                 {
  1921.                                                     forGoogleString += lat + "," + lon + "|";
  1922.                                                     forKMLLeft += xL + "," + yL + ",0 \r\n";
  1923.                                                     kmlRightList.Add(xR + "," + yR + ",0 \r\n");
  1924.                                                     forKML += lat + "," + lon + ",0 \r\n";
  1925.                                                 }
  1926.                                                 speeds.Add(speed);
  1927.                                                 PlayerPrefs.SetString("map" + SaveController.Instance.data.saveIndex, forGoogleString);
  1928.                                                 needToAddPosition = false;
  1929.                                             }
  1930.                                             else
  1931.                                             {
  1932.                                                 needToAddPosition = true;
  1933.                                             }
  1934.                                         }
  1935.                                         if (SquareController.Instance.isTracked)
  1936.                                         {
  1937.                                             if (needToAddSquare)
  1938.                                             {
  1939.                                                 if (CheckWorkType.Instance.typeId != 8)
  1940.                                                 {
  1941.                                                     kmlSquare += lat + "," + lon + ",0 \r\n";
  1942.                                                 }
  1943.                                                 else
  1944.                                                 {
  1945.                                                     kmlSquare += lat + "," + lon + "," + altitude + " \r\n";
  1946.                                                 }
  1947.                                                 if (string.IsNullOrEmpty(kmlStartSquare))
  1948.                                                 {
  1949.                                                     kmlStartSquare = kmlSquare;
  1950.                                                 }
  1951.                                                 needToAddSquare = false;
  1952.                                             }
  1953.                                             else
  1954.                                             {
  1955.                                                 needToAddSquare = true;
  1956.                                             }
  1957.                                         }
  1958.                                         if (newPoint != null)
  1959.                                         {
  1960.                                             bool needToRotate = false;
  1961.                                             NextPoint = newPoint;
  1962.                                             if (NextPoint.transform.position != prevSector.transform.position)
  1963.                                             {
  1964.                                                 prevSector.transform.LookAt(NextPoint.transform);
  1965.                                                 NextPoint.transform.rotation = prevSector.transform.rotation;
  1966.                                                 needToRotate = true;
  1967.                                             }
  1968.  
  1969.                                             int i = selectedPoints.IndexOf(NextPoint);
  1970.                                             for (int k = i; k >= 0; k--)
  1971.                                             {
  1972.                                                 selectedPoints.RemoveAt(k);
  1973.                                             }
  1974.  
  1975.                                             if (isMoving)
  1976.                                             {
  1977.                                                 if (trailer[0].transform.parent != null && ponitCount == 3)
  1978.                                                 {
  1979.  
  1980.  
  1981.                                                     //SetZOffset(normalOffset);
  1982.  
  1983.                                                     StartCoroutine(SmoothChangeJoint(normalOffset + 1, Gz * ((pointsDealey) * (sectorsDealey - selectedPoints.Count + 1)) * 2));// SetZOffset(normalOffset);
  1984.  
  1985.                                                     ponitCount = 0;
  1986.  
  1987.                                                     transform.LookAt(NextPoint.transform);
  1988.                                                     transform.LookAt(NextPoint.transform);
  1989.                                                     transform.LookAt(NextPoint.transform);
  1990.                                                     transform.LookAt(NextPoint.transform);
  1991.                                                     foreach (GameObject go in trailer)
  1992.                                                         go.transform.SetParent(null);
  1993.  
  1994.  
  1995.                                                     MainRightPanel.Instance.ContinueDraw();
  1996.                                                     isBack = false;
  1997.                                                 }
  1998.                                                 else if (trailer[0].transform.parent != null && ponitCount < 3)
  1999.                                                 {
  2000.                                                     //transform.LookAt(NextPoint.transform);
  2001.                                                     //transform.position = NextPoint.transform.position;
  2002.                                                     ponitCount++;
  2003.                                                 }
  2004.  
  2005.                                             }
  2006.  
  2007.                                             Vector3 heading = NextPoint.transform.position - transform.position;
  2008.                                             float dot = Vector3.Dot(heading, transform.forward);
  2009.                                             if (dot < -1 && trailer[0].transform.parent == null)
  2010.                                             {
  2011.                                                 /* Debug.Log("Dot: " + dot);
  2012.                                                  StopCoroutine("LookToEuler");
  2013.                                                  MainRightPanel.Instance.EndDraw();
  2014.  
  2015.                                                  foreach (GameObject go in trailer)
  2016.                                                  {
  2017.                                                      go.transform.SetParent(transform);
  2018.                                                      go.transform.localEulerAngles = Vector3.zero;
  2019.  
  2020.                                                  }
  2021.                                                  SetZOffset(0, 0);
  2022.                                                  transform.LookAt(NextPoint.transform);
  2023.                                                  */
  2024.                                             }
  2025.  
  2026.                                             isMoving = true;
  2027.  
  2028.                                             CheckForMinMax(new Vector2(NextPoint.transform.position.x, NextPoint.transform.position.z));
  2029.  
  2030.                                             if (!isBack)
  2031.                                             {
  2032.                                                 float angle = AngleSigned(transform.forward, NextPoint.transform.position - transform.position, transform.up);
  2033.                                                 if (movCor != null)
  2034.                                                 {
  2035.                                                     //StopCoroutine(movCor);
  2036.                                                 }
  2037.                                                 ChangeSppedLimit();
  2038.                                                 movCor = StartCoroutine(MoveToPosition(transform, prevSector.transform, NextPoint.transform.position, Gz * (pointsDealey * (sectorsDealey - selectedPoints.Count + 1))));
  2039. #if UNITY_WSA_10_0
  2040.                                                 if (string.IsNullOrEmpty(startingDate) && !string.IsNullOrEmpty(uBluetooth.currentData))
  2041.                                                 {
  2042.                                                     startingDate = uBluetooth.currentData;
  2043.                                                     PlayerPrefs.SetString("date" + SaveController.Instance.data.saveIndex, startingDate);
  2044.                                                 }
  2045.                                                 else
  2046.                                                 {
  2047.                                                     currentDate = uBluetooth.currentData;
  2048.                                                     if (currentDate.EndsWith("18"))
  2049.                                                     {
  2050.                                                         //PlayerPrefs.SetInt("NeedUpdate", 1);
  2051.                                                     }
  2052.                                                 }
  2053. #else
  2054.                                                 if (string.IsNullOrEmpty(startingDate) && !string.IsNullOrEmpty(NMEAParser.Instance.currentData))
  2055.                                                 {
  2056.                                                     startingDate = NMEAParser.Instance.currentData;
  2057.                                                     PlayerPrefs.SetString("date" + SaveController.Instance.data.saveIndex, startingDate);
  2058.                                                 }
  2059.                                                 else
  2060.                                                 {
  2061.                                                     currentDate = NMEAParser.Instance.currentData;
  2062.                                                 }
  2063. #endif
  2064.  
  2065.  
  2066.  
  2067.                                                 if (firstPos)
  2068.                                                 {
  2069.  
  2070.                                                     SetZOffset(normalOffset);
  2071.                                                     foreach (GameObject go in trailer)
  2072.                                                         go.transform.SetParent(null);
  2073.  
  2074.                                                     SquareController.Instance.CheckAfterMove();
  2075.                                                     CurveController.Instance.CheckAfterMove();
  2076.                                                     ParalelsController.Instance.CheckAfterMove();
  2077.  
  2078.                                                 }
  2079.                                                 firstPos = false;
  2080.                                                 if (needToRotate)
  2081.                                                 {
  2082.                                                     if (rotCor != null)
  2083.                                                         StopCoroutine(rotCor);
  2084.  
  2085.                                                     if (dot > -4)
  2086.                                                     {
  2087.                                                         rotCor = StartCoroutine(LookToEuler(NextPoint.transform.rotation, Gz * ((pointsDealey) * (sectorsDealey - selectedPoints.Count + 1))));
  2088.                                                         if (trailer[0].transform.parent != null)
  2089.                                                         {
  2090.                                                             trailer[0].transform.SetParent(transform);
  2091.                                                             trailer[0].transform.localEulerAngles = Vector3.zero;
  2092.                                                         }
  2093.                                                     }
  2094.                                                     else
  2095.                                                     {
  2096.                                                         if (trailer[0].transform.parent == null)
  2097.                                                         {
  2098.                                                             if (rotCor != null)
  2099.                                                                 StopCoroutine(rotCor);
  2100.                                                             StopCoroutine(movCor);
  2101.                                                             MainRightPanel.Instance.EndDraw();
  2102.                                                             foreach (GameObject go in trailer)
  2103.                                                             {
  2104.  
  2105.                                                                 go.transform.SetParent(transform);
  2106.                                                                 go.transform.localEulerAngles = Vector3.zero;
  2107.                                                                 StopCoroutine("SmoothChangeJoint");
  2108.                                                                 //SetZOffset(0, 0);
  2109.                                                                 startingRotate = trackedPoint.rotation;
  2110.                                                                 StartCoroutine(SmoothChangeJoint(0, Gz * ((pointsDealey) * (sectorsDealey - selectedPoints.Count + 1))));// SetZOffset(normalOffset);//SetZOffset(0, 0);
  2111.                                                                 ponitCount = 0;
  2112.                                                                 //transform.LookAt(NextPoint.transform);
  2113.                                                             }
  2114.                                                             isBack = true;
  2115.                                                         }
  2116.                                                     }
  2117.                                                 }
  2118.                                             }
  2119.                                             else
  2120.                                             {
  2121.                                                 StopCoroutine(movCor);
  2122.                                             }
  2123.  
  2124.                                             /*else
  2125.                                             {
  2126.  
  2127.                                             }*/
  2128.  
  2129.                                             Points.Clear();
  2130.  
  2131.                                         }
  2132.  
  2133.  
  2134.                                     }
  2135.  
  2136.  
  2137.  
  2138.                                     pointsCount = 0;
  2139.                                 }
  2140.                                 else if (!isMoving && selectedPoints.Count == 1 && point.transform.position != transform.position)
  2141.                                 {
  2142.  
  2143.                                 }
  2144.                                 if (Points.Count >= 100)
  2145.                                 {
  2146.                                     Points.RemoveRange(0, 50);
  2147.                                 }
  2148.  
  2149.                             }
  2150.                             else if (ConstConfig.isInnerGPS)
  2151.                             {
  2152.                                 Points.Add(point);
  2153.                                 currentTime = 0;
  2154.  
  2155.                                 pointsCount++;
  2156.  
  2157.                                 if (pointsCount >= pointsDealey)
  2158.                                 {
  2159.                                    
  2160.                                     point.transform.position = CreateSector();
  2161.  
  2162.                                     if (selectedPoints.Count >= sectorsDealey)
  2163.                                     {
  2164.                                         bool movingState = isMoving;
  2165.                                         if (!isMoving)
  2166.                                         {
  2167.                                             transform.LookAt(point.transform);
  2168.                                         }
  2169.  
  2170.                                         GameObject prevSector = NextPoint;
  2171.                                         GameObject newPoint = GetFinestPosition();
  2172.  
  2173.                                         float distToPoint = Vector3.Distance(transform.position, newPoint.transform.position) / 6.23f;
  2174.                                         float nowSpeed = distToPoint * 60 * 60 / 1000;
  2175.                                         speed = nowSpeed;
  2176.                                         speedText.text = Math.Round(speed, 0).ToString();
  2177.  
  2178.                                         prevSector.GetComponent<MeshRenderer>().material = PassedPointMaterial;
  2179.                                         if (movedCount > 2 && CheckWorkType.Instance.typeId == 8)
  2180.                                         {
  2181.  
  2182.                                             float widthM = (float)SaveController.Instance.data.widthM;
  2183.                                             float widthSM = (float)SaveController.Instance.data.widthSM / 100;
  2184.                                             float delt = (widthM + widthSM) / 2;
  2185.  
  2186.                                             double xM =
  2187.                                                 KMLController.xToLon(
  2188.                                                 (-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).x +
  2189.                                                  firstPosition.x) / 50);
  2190.                                             double yM =
  2191.                                                 KMLController.zToLat(
  2192.                                                 (-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).z +
  2193.                                                  firstPosition.y) / 60);
  2194.                                             gpxString += xM + "," + yM + "," + Math.Round(speed, 2) + "," + altitude + "," + currentDate +
  2195.                                                          " \r\n";
  2196.  
  2197.                                         }
  2198.  
  2199.                                         if (MainRightPanel.Instance.Paint)
  2200.                                         {
  2201.                                             if (needToAddPosition)
  2202.                                             {
  2203.                                                 float delt = (SaveController.Instance.data.widthM + SaveController.Instance.data.widthSM / 100) / 2;
  2204.                                                 double xR = KMLController.xToLon((-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).x + firstPosition.x) / 50);
  2205.                                                 double yR = KMLController.zToLat((-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).z + firstPosition.y) / 60);
  2206.                                                 double xL = KMLController.xToLon((-(arrowTransform.position + (-arrowTransform.up * (delt * 6.278353f))).x + firstPosition.x) / 50);
  2207.                                                 double yL = KMLController.zToLat((-(arrowTransform.position + (-arrowTransform.up * (delt * 6.278353f))).z + firstPosition.y) / 60);
  2208.                                                 if (CheckWorkType.Instance.typeId == 8)
  2209.                                                 {
  2210.                                                     if (!SquareController.Instance.newMode ||
  2211.                                                                             (SquareController.Instance.newMode &&
  2212.                                                                              SquareController.InSquare(SquareController.Instance.linePositions.ToArray(),
  2213.                                                                                  transform.position)))
  2214.                                                     {
  2215.                                                         forGoogleString += lat + "," + lon + "|";
  2216.                                                         forKMLLeft += xL + "," + yL + "," + altitude + " \r\n";
  2217.                                                         kmlRightList.Add(xR + "," + yR + "," + altitude + " \r\n");
  2218.                                                         forKML += lat + "," + lon + "," + altitude + " \r\n";
  2219.                                                     }
  2220.                                                     double xM = KMLController.xToLon((-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).x + firstPosition.x) / 50);
  2221.                                                     double yM = KMLController.zToLat((-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).z + firstPosition.y) / 60);
  2222.                                                     //gpxString += xM + "," + yM + "," + Math.Round(speed, 2) + ","+altitude+","+currentDate+" \r\n";
  2223.                                                     minSpeed = SpeedWindow.Instance.CurrentMinSpeed;
  2224.                                                     maxSpeed = SpeedWindow.Instance.CurrentMaxSpeed;
  2225.  
  2226.                                                 }
  2227.                                                 else
  2228.                                                 {
  2229.                                                     forGoogleString += lat + "," + lon + "|";
  2230.                                                     forKMLLeft += xL + "," + yL + ",0 \r\n";
  2231.                                                     kmlRightList.Add(xR + "," + yR + ",0 \r\n");
  2232.                                                     forKML += lat + "," + lon + ",0 \r\n";
  2233.                                                 }
  2234.                                                 speeds.Add(speed);
  2235.                                                 PlayerPrefs.SetString("map" + SaveController.Instance.data.saveIndex, forGoogleString);
  2236.                                                 needToAddPosition = false;
  2237.                                             }
  2238.                                             else
  2239.                                             {
  2240.                                                 needToAddPosition = true;
  2241.                                             }
  2242.                                         }
  2243.                                         if (SquareController.Instance.isTracked)
  2244.                                         {
  2245.                                             if (needToAddSquare)
  2246.                                             {
  2247.                                                 if (CheckWorkType.Instance.typeId != 8)
  2248.                                                 {
  2249.                                                     kmlSquare += lat + "," + lon + ",0 \r\n";
  2250.                                                 }
  2251.                                                 else
  2252.                                                 {
  2253.                                                     kmlSquare += lat + "," + lon + "," + altitude + " \r\n";
  2254.                                                 }
  2255.                                                 if (string.IsNullOrEmpty(kmlStartSquare))
  2256.                                                 {
  2257.                                                     kmlStartSquare = kmlSquare;
  2258.                                                 }
  2259.                                                 needToAddSquare = false;
  2260.                                             }
  2261.                                             else
  2262.                                             {
  2263.                                                 needToAddSquare = true;
  2264.                                             }
  2265.                                         }
  2266.                                         if (newPoint != null)
  2267.                                         {
  2268.                                             bool needToRotate = false;
  2269.                                             NextPoint = newPoint;
  2270.                                             if (NextPoint.transform.position != prevSector.transform.position)
  2271.                                             {
  2272.                                                 prevSector.transform.LookAt(NextPoint.transform);
  2273.                                                 NextPoint.transform.rotation = prevSector.transform.rotation;
  2274.                                                 needToRotate = true;
  2275.                                             }
  2276.  
  2277.                                             int i = selectedPoints.IndexOf(NextPoint);
  2278.                                             for (int k = i; k >= 0; k--)
  2279.                                             {
  2280.                                                 selectedPoints.RemoveAt(k);
  2281.                                             }
  2282.  
  2283.                                             if (isMoving)
  2284.                                             {
  2285.                                                 if (trailer[0].transform.parent != null && ponitCount == 3)
  2286.                                                 {
  2287.  
  2288.  
  2289.                                                     //SetZOffset(normalOffset);
  2290.  
  2291.                                                     StartCoroutine(SmoothChangeJoint(normalOffset + 1, Gz * ((pointsDealey) * (sectorsDealey - selectedPoints.Count + 1)) * 2));// SetZOffset(normalOffset);
  2292.  
  2293.                                                     ponitCount = 0;
  2294.  
  2295.                                                     transform.LookAt(NextPoint.transform);
  2296.                                                     transform.LookAt(NextPoint.transform);
  2297.                                                     transform.LookAt(NextPoint.transform);
  2298.                                                     transform.LookAt(NextPoint.transform);
  2299.                                                     foreach (GameObject go in trailer)
  2300.                                                         go.transform.SetParent(null);
  2301.  
  2302.  
  2303.                                                     MainRightPanel.Instance.ContinueDraw();
  2304.                                                     isBack = false;
  2305.                                                 }
  2306.                                                 else if (trailer[0].transform.parent != null && ponitCount < 3)
  2307.                                                 {
  2308.                                                     //transform.LookAt(NextPoint.transform);
  2309.                                                     //transform.position = NextPoint.transform.position;
  2310.                                                     ponitCount++;
  2311.                                                 }
  2312.  
  2313.                                             }
  2314.  
  2315.                                             Vector3 heading = NextPoint.transform.position - transform.position;
  2316.                                             float dot = Vector3.Dot(heading, transform.forward);
  2317.                                             if (dot < -1 && trailer[0].transform.parent == null)
  2318.                                             {
  2319.                                                 /* Debug.Log("Dot: " + dot);
  2320.                                                  StopCoroutine("LookToEuler");
  2321.                                                  MainRightPanel.Instance.EndDraw();
  2322.  
  2323.                                                  foreach (GameObject go in trailer)
  2324.                                                  {
  2325.                                                      go.transform.SetParent(transform);
  2326.                                                      go.transform.localEulerAngles = Vector3.zero;
  2327.  
  2328.                                                  }
  2329.                                                  SetZOffset(0, 0);
  2330.                                                  transform.LookAt(NextPoint.transform);
  2331.                                                  */
  2332.                                             }
  2333.  
  2334.                                             isMoving = true;
  2335.  
  2336.                                             CheckForMinMax(new Vector2(NextPoint.transform.position.x, NextPoint.transform.position.z));
  2337.  
  2338.                                             if (!isBack)
  2339.                                             {
  2340.                                                 float angle = AngleSigned(transform.forward, NextPoint.transform.position - transform.position, transform.up);
  2341.                                                 if (movCor != null)
  2342.                                                 {
  2343.                                                     //StopCoroutine(movCor);
  2344.                                                 }
  2345.                                                 ChangeSppedLimit();
  2346.                                                 movCor = StartCoroutine(MoveToPosition(transform, prevSector.transform, NextPoint.transform.position, Gz * (pointsDealey * (sectorsDealey - selectedPoints.Count + 1))));
  2347. #if UNITY_WSA_10_0
  2348.                                                 if (string.IsNullOrEmpty(startingDate) && !string.IsNullOrEmpty(uBluetooth.currentData))
  2349.                                                 {
  2350.                                                     startingDate = uBluetooth.currentData;
  2351.                                                     PlayerPrefs.SetString("date" + SaveController.Instance.data.saveIndex, startingDate);
  2352.                                                 }
  2353.                                                 else
  2354.                                                 {
  2355.                                                     currentDate = uBluetooth.currentData;
  2356.                                                     if (currentDate.EndsWith("18"))
  2357.                                                     {
  2358.                                                         //PlayerPrefs.SetInt("NeedUpdate", 1);
  2359.                                                     }
  2360.                                                 }
  2361. #else
  2362.                                                 if (string.IsNullOrEmpty(startingDate) && !string.IsNullOrEmpty(NMEAParser.Instance.currentData))
  2363.                                                 {
  2364.                                                     startingDate = NMEAParser.Instance.currentData;
  2365.                                                     PlayerPrefs.SetString("date" + SaveController.Instance.data.saveIndex, startingDate);
  2366.                                                 }
  2367.                                                 else
  2368.                                                 {
  2369.                                                     currentDate = NMEAParser.Instance.currentData;
  2370.                                                 }
  2371. #endif
  2372.  
  2373.  
  2374.  
  2375.                                                 if (firstPos)
  2376.                                                 {
  2377.  
  2378.                                                     SetZOffset(normalOffset);
  2379.                                                     foreach (GameObject go in trailer)
  2380.                                                         go.transform.SetParent(null);
  2381.  
  2382.                                                     SquareController.Instance.CheckAfterMove();
  2383.                                                     CurveController.Instance.CheckAfterMove();
  2384.                                                     ParalelsController.Instance.CheckAfterMove();
  2385.  
  2386.                                                 }
  2387.                                                 firstPos = false;
  2388.                                                 if (needToRotate)
  2389.                                                 {
  2390.                                                     if (rotCor != null)
  2391.                                                         StopCoroutine(rotCor);
  2392.  
  2393.                                                     if (dot > -4)
  2394.                                                     {
  2395.                                                         rotCor = StartCoroutine(LookToEuler(NextPoint.transform.rotation, Gz * ((pointsDealey) * (sectorsDealey - selectedPoints.Count + 1))));
  2396.                                                         if (trailer[0].transform.parent != null)
  2397.                                                         {
  2398.                                                             trailer[0].transform.SetParent(transform);
  2399.                                                             trailer[0].transform.localEulerAngles = Vector3.zero;
  2400.                                                         }
  2401.                                                     }
  2402.                                                     else
  2403.                                                     {
  2404.                                                         if (trailer[0].transform.parent == null)
  2405.                                                         {
  2406.                                                             if (rotCor != null)
  2407.                                                                 StopCoroutine(rotCor);
  2408.                                                             StopCoroutine(movCor);
  2409.                                                             MainRightPanel.Instance.EndDraw();
  2410.                                                             foreach (GameObject go in trailer)
  2411.                                                             {
  2412.  
  2413.                                                                 go.transform.SetParent(transform);
  2414.                                                                 go.transform.localEulerAngles = Vector3.zero;
  2415.                                                                 StopCoroutine("SmoothChangeJoint");
  2416.                                                                 //SetZOffset(0, 0);
  2417.                                                                 startingRotate = trackedPoint.rotation;
  2418.                                                                 StartCoroutine(SmoothChangeJoint(0, Gz * ((pointsDealey) * (sectorsDealey - selectedPoints.Count + 1))));// SetZOffset(normalOffset);//SetZOffset(0, 0);
  2419.                                                                 ponitCount = 0;
  2420.                                                                 //transform.LookAt(NextPoint.transform);
  2421.                                                             }
  2422.                                                             isBack = true;
  2423.                                                         }
  2424.                                                     }
  2425.                                                 }
  2426.                                             }
  2427.                                             else
  2428.                                             {
  2429.                                                 StopCoroutine(movCor);
  2430.                                             }
  2431.  
  2432.                                             /*else
  2433.                                             {
  2434.  
  2435.                                             }*/
  2436.  
  2437.                                             Points.Clear();
  2438.  
  2439.                                         }
  2440.  
  2441.  
  2442.                                     }
  2443.  
  2444.  
  2445.  
  2446.                                     pointsCount = 0;
  2447.                                 }
  2448.                                 else if (!isMoving && selectedPoints.Count == 1 && point.transform.position != transform.position)
  2449.                                 {
  2450.  
  2451.                                 }
  2452.                                 if (Points.Count >= 100)
  2453.                                 {
  2454.                                     Points.RemoveRange(0, 50);
  2455.                                 }
  2456.  
  2457.  
  2458.                             }
  2459.                             else
  2460.                             {
  2461.                                 StopCoroutine("MoveToPosition");
  2462.                             }
  2463.  
  2464.                         }
  2465.                     if (sendCount == 1)
  2466.                     {
  2467.                         GenerateSendData();
  2468.                         sendCount = 0;
  2469.                     }
  2470.                     sendCount++;
  2471.  
  2472.                         if(IsConnected && !ConstConfig.isInnerGPS)
  2473.                         {
  2474.                             string nmeaString = uBluetooth.GetMinimalMNEAString();
  2475.                             NMEAParser.Instance.ParseMomentNMEA(nmeaString);
  2476.                         }
  2477.                 }
  2478.  
  2479. #endif
  2480.                 }
  2481.  
  2482.             }
  2483.             catch
  2484.             {
  2485.  
  2486.             }
  2487.  
  2488.             yield return new WaitForSeconds(Gz);
  2489.         }
  2490.  
  2491.  
  2492.     }
  2493.  
  2494.     private int sendCount;
  2495.     private int ponitCount = 0;
  2496.     private Coroutine rotCor = null;
  2497.     private Coroutine movCor = null;
  2498.     public bool isBack = false;
  2499.     private float altitude = 0;
  2500.     private bool setPositionFromSave = false;
  2501.     public bool canPaint = true;
  2502.     private IEnumerator GetPositionsFromNMEA()
  2503.     {
  2504.         NMEAParser.Instance.StartGPS();
  2505.         while (true)
  2506.         {
  2507.  
  2508.             GPSData ajObject = NMEAParser.Instance.newData;
  2509.             if (ajObject != null)
  2510.             {
  2511.                 float xp = KMLController.lonToX(ajObject.position.x) * 50f;
  2512.                 float yp = KMLController.latToZ(ajObject.position.y) * 60f;
  2513.                 altitude = ajObject.altitude;
  2514.                 Vector2 newPos = new Vector2(xp, yp);
  2515.                 if (SaveController.Instance.data.debugData.pointsDealey == 0.1f)
  2516.                     newPos = new Vector2(newPos.x + UnityEngine.Random.Range(-1.03f, 1.03f), newPos.y + UnityEngine.Random.Range(-1.03f, 1.03f));
  2517.                 speed = ajObject.speed;
  2518.                 //if (ajObject.position.x != 0 && ajObject.position.y != 0)
  2519.                 //{
  2520.                 //    if (!CachedDynamicTileManager.Instance.Started)
  2521.                 //    {
  2522.                 //        CachedDynamicTileManager.Instance.Latitude = ajObject.position.y;
  2523.                 //        CachedDynamicTileManager.Instance.Longitude = ajObject.position.x;
  2524.                 //        CachedDynamicTileManager.Instance.StartParse();
  2525.                 //    }
  2526.                 //}
  2527.  
  2528.                 speedText.text = Math.Round(speed, 1).ToString();
  2529.  
  2530.                 if (ajObject.position.x != 0 && ajObject.position.y != 0 && speed > 1f)
  2531.                 {
  2532.  
  2533.                    
  2534.                     if (!SendLimit)
  2535.                     {
  2536. #if UNITY_EDITOR || !UNITY_WSA_10_0
  2537.                         if (gpsActivityJavaClass != null && PlayerPrefs.GetString("deviceId").Length != 10)
  2538.                         {
  2539.                             gpsActivityJavaClass.CallStatic<string>("SendData", PlayerPrefs.GetString("deviceSpeed") + "\r\n");
  2540.                             SendLimit = true;
  2541.                         }
  2542. #else
  2543. #endif
  2544.                     }
  2545.                     if (firstPosition == Vector2.zero)
  2546.                     {
  2547.                         if (SaveController.Instance.data.startingPos != Vector2.zero)
  2548.                         {
  2549.                             firstPosition = SaveController.Instance.data.startingPos;
  2550.                         }
  2551.                         else
  2552.                         {
  2553.                             SaveController.Instance.data.startingPos = newPos;
  2554.                             firstPosition = newPos;
  2555.                             SaveController.Instance.InsertFristPosition(firstPosition);
  2556.                         }
  2557.                     }
  2558.  
  2559.                     var point = Instantiate(NextPoint);
  2560.                     point.gameObject.transform.SetParent(parent.transform, false);
  2561.                     point.transform.localRotation = NextPoint.gameObject.transform.localRotation;
  2562.                     point.transform.localPosition = new Vector3(firstPosition.x - newPos.x, NextPoint.transform.position.y, firstPosition.y - newPos.y);
  2563.  
  2564.                     //Debug.Log("xpn: " + (firstPosition.x - newPos.x).ToString("F4") + "  ynp: " + (firstPosition.y - newPos.y).ToString("F4"));
  2565.  
  2566.                     if (speed > speedLimit)// && speed > 0.01f)
  2567.                     {
  2568.                         Points.Add(point);
  2569.                         currentTime = 0;
  2570.  
  2571.                         pointsCount++;
  2572.  
  2573.                         if (pointsCount >= pointsDealey)
  2574.                         {
  2575.                             point.transform.position = CreateSector();
  2576.  
  2577.                             if (selectedPoints.Count >= sectorsDealey)
  2578.                             {
  2579.                                 bool movingState = isMoving;
  2580.                                 if (!isMoving)
  2581.                                 {
  2582.                                     transform.LookAt(point.transform);
  2583.                                 }
  2584.  
  2585.                                 GameObject prevSector = NextPoint;
  2586.                                 GameObject newPoint = GetFinestPosition();
  2587.                                 prevSector.GetComponent<MeshRenderer>().material = PassedPointMaterial;
  2588.  
  2589.                                 if (movedCount > 2 && CheckWorkType.Instance.typeId == 8)
  2590.                                 {
  2591.  
  2592.                                     float widthM = (float)SaveController.Instance.data.widthM;
  2593.                                     float widthSM = (float)SaveController.Instance.data.widthSM / 100;
  2594.                                     float delt = (widthM + widthSM) / 2;
  2595.  
  2596.                                     double xM =
  2597.                                         KMLController.xToLon(
  2598.                                         (-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f))
  2599.                                              .x +
  2600.                                          firstPosition.x) / 50);
  2601.                                     double yM =
  2602.                                         KMLController.zToLat(
  2603.                                         (-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f))
  2604.                                              .z +
  2605.                                          firstPosition.y) / 60);
  2606.                                     gpxString += xM + "," + yM + "," + Math.Round(speed, 2) + "," + altitude +
  2607.                                                  "," + currentDate +
  2608.                                                  " \r\n";
  2609.  
  2610.                                 }
  2611.  
  2612.                                 if (MainRightPanel.Instance.Paint)
  2613.                                 {
  2614.                                     if (needToAddPosition)
  2615.                                     {
  2616.                                         float delt = (SaveController.Instance.data.widthM +
  2617.                                                       SaveController.Instance.data.widthSM / 100) / 2;
  2618.                                         double xR =
  2619.                                             KMLController.xToLon(
  2620.                                             (-(arrowTransform.position +
  2621.                                                arrowTransform.up * (delt * 6.278353f)).x +
  2622.                                              firstPosition.x) / 50);
  2623.                                         double yR =
  2624.                                             KMLController.zToLat(
  2625.                                             (-(arrowTransform.position +
  2626.                                                arrowTransform.up * (delt * 6.278353f)).z +
  2627.                                              firstPosition.y) / 60);
  2628.                                         double xL =
  2629.                                             KMLController.xToLon(
  2630.                                             (-(arrowTransform.position +
  2631.                                                (-arrowTransform.up * (delt * 6.278353f))).x +
  2632.                                              firstPosition.x) / 50);
  2633.                                         double yL =
  2634.                                             KMLController.zToLat(
  2635.                                             (-(arrowTransform.position +
  2636.                                                (-arrowTransform.up * (delt * 6.278353f))).z +
  2637.                                              firstPosition.y) / 60);
  2638.                                         if (CheckWorkType.Instance.typeId == 8)
  2639.                                         {
  2640.                                             if (!SquareController.Instance.newMode ||
  2641.                                                 (SquareController.Instance.newMode &&
  2642.                                                  SquareController.InSquare(
  2643.                                                      SquareController.Instance.linePositions.ToArray(),
  2644.                                                      transform.position)))
  2645.                                             {
  2646.                                                 forGoogleString += ajObject.x + "," + ajObject.y + "|";
  2647.                                                 forKMLLeft += xL + "," + yL + "," + altitude + " \r\n";
  2648.                                                 kmlRightList.Add(xR + "," + yR + "," + altitude + " \r\n");
  2649.                                                 forKML += ajObject.x + "," + ajObject.y + "," + altitude + " \r\n";
  2650.                                             }
  2651.                                             double xM =
  2652.                                                 KMLController.xToLon(
  2653.                                                 (-(arrowTransform.position +
  2654.                                                    arrowTransform.up * (delt * 6.278353f)).x +
  2655.                                                  firstPosition.x) / 50);
  2656.                                             double yM =
  2657.                                                 KMLController.zToLat(
  2658.                                                 (-(arrowTransform.position +
  2659.                                                    arrowTransform.up * (delt * 6.278353f)).z +
  2660.                                                  firstPosition.y) / 60);
  2661.                                             //gpxString += xM + "," + yM + "," + Math.Round(speed, 2) + ","+altitude+","+currentDate+" \r\n";
  2662.                                             minSpeed = SpeedWindow.Instance.CurrentMinSpeed;
  2663.                                             maxSpeed = SpeedWindow.Instance.CurrentMaxSpeed;
  2664.                                         }
  2665.                                         else
  2666.                                         {
  2667.                                             if (!SquareController.Instance.newMode ||
  2668.                                                 (SquareController.Instance.newMode &&
  2669.                                                  SquareController.InSquare(
  2670.                                                      SquareController.Instance.linePositions.ToArray(),
  2671.                                                      transform.position)))
  2672.                                             {
  2673.                                                 forGoogleString += ajObject.x + "," + ajObject.y + "|";
  2674.                                                 forKMLLeft += xL + "," + yL + ",0 \r\n";
  2675.                                                 kmlRightList.Add(xR + "," + yR + ",0 \r\n");
  2676.                                                 forKML += ajObject.x + "," + ajObject.y + ",0 \r\n";
  2677.                                             }
  2678.                                         }
  2679.                                         PlayerPrefs.SetString(
  2680.                                             "map" + SaveController.Instance.data.saveIndex, forGoogleString);
  2681.                                         needToAddPosition = false;
  2682.                                     }
  2683.                                     else
  2684.                                     {
  2685.                                         needToAddPosition = true;
  2686.                                     }
  2687.                                     speeds.Add(speed);
  2688.                                 }
  2689.                                 if (SquareController.Instance.isTracked)
  2690.                                 {
  2691.                                     if (needToAddSquare)
  2692.                                     {
  2693.                                         if (CheckWorkType.Instance.typeId == 8)
  2694.                                         {
  2695.                                             kmlSquare += ajObject.x + "," + ajObject.y + "," + altitude + " \r\n";
  2696.                                         }
  2697.                                         else
  2698.                                         {
  2699.                                             kmlSquare += ajObject.x + "," + ajObject.y + ",0 \r\n";
  2700.                                         }
  2701.                                         if (string.IsNullOrEmpty(kmlStartSquare))
  2702.                                         {
  2703.                                             kmlStartSquare = kmlSquare;
  2704.                                         }
  2705.                                         needToAddSquare = false;
  2706.                                     }
  2707.                                     else
  2708.                                     {
  2709.                                         needToAddSquare = true;
  2710.                                     }
  2711.                                 }
  2712.  
  2713.                                 if (newPoint != null)
  2714.                                 {
  2715.                                     bool needToRotate = false;
  2716.                                     NextPoint = newPoint;
  2717.                                     if (NextPoint.transform.position != prevSector.transform.position)
  2718.                                     {
  2719.                                         prevSector.transform.LookAt(NextPoint.transform);
  2720.                                         NextPoint.transform.rotation = prevSector.transform.rotation;
  2721.                                         needToRotate = true;
  2722.                                     }
  2723.  
  2724.                                     int i = selectedPoints.IndexOf(NextPoint);
  2725.                                     for (int k = i; k >= 0; k--)
  2726.                                     {
  2727.                                         selectedPoints.RemoveAt(k);
  2728.                                     }
  2729.  
  2730.                                     if (isMoving)
  2731.                                     {
  2732.                                         if (trailer[0].transform.parent != null && ponitCount == 3)
  2733.                                         {
  2734.  
  2735.  
  2736.                                             //SetZOffset(normalOffset);
  2737.  
  2738.                                             StartCoroutine(SmoothChangeJoint(normalOffset + 1,
  2739.                                                 Gz *
  2740.                                                 ((pointsDealey) * (sectorsDealey - selectedPoints.Count + 1)) *
  2741.                                                 2)); // SetZOffset(normalOffset);
  2742.  
  2743.                                             ponitCount = 0;
  2744.  
  2745.                                             transform.LookAt(NextPoint.transform);
  2746.                                             transform.LookAt(NextPoint.transform);
  2747.                                             transform.LookAt(NextPoint.transform);
  2748.                                             transform.LookAt(NextPoint.transform);
  2749.                                             foreach (GameObject go in trailer)
  2750.                                                 go.transform.SetParent(null);
  2751.  
  2752.  
  2753.                                             MainRightPanel.Instance.ContinueDraw();
  2754.                                             isBack = false;
  2755.                                         }
  2756.                                         else if (trailer[0].transform.parent != null && ponitCount < 3)
  2757.                                         {
  2758.                                             //transform.LookAt(NextPoint.transform);
  2759.                                             //transform.position = NextPoint.transform.position;
  2760.                                             ponitCount++;
  2761.                                         }
  2762.  
  2763.                                     }
  2764.  
  2765.                                     Vector3 heading = NextPoint.transform.position - transform.position;
  2766.                                     float dot = Vector3.Dot(heading, transform.forward);
  2767.                                     if (dot < -1 && trailer[0].transform.parent == null)
  2768.                                     {
  2769.                                         /* Debug.Log("Dot: " + dot);
  2770.                                          StopCoroutine("LookToEuler");
  2771.                                          MainRightPanel.Instance.EndDraw();
  2772.  
  2773.                                          foreach (GameObject go in trailer)
  2774.                                          {
  2775.                                              go.transform.SetParent(transform);
  2776.                                              go.transform.localEulerAngles = Vector3.zero;
  2777.  
  2778.                                          }
  2779.                                          SetZOffset(0, 0);
  2780.                                          transform.LookAt(NextPoint.transform);
  2781.                                          */
  2782.                                     }
  2783.  
  2784.                                     isMoving = true;
  2785.  
  2786.                                     CheckForMinMax(new Vector2(NextPoint.transform.position.x,
  2787.                                         NextPoint.transform.position.z));
  2788.  
  2789.                                     if (!isBack)
  2790.                                     {
  2791.                                         float angle = AngleSigned(transform.forward,
  2792.                                             NextPoint.transform.position - transform.position, transform.up);
  2793.                                         if (movCor != null)
  2794.                                         {
  2795.                                             StopCoroutine(movCor);
  2796.                                         }
  2797.                                         ChangeSppedLimit();
  2798.                                         movCor =
  2799.                                             StartCoroutine(MoveToPosition(transform, prevSector.transform,
  2800.                                                 NextPoint.transform.position,
  2801.                                                 Gz *
  2802.                                                 (pointsDealey * (sectorsDealey - selectedPoints.Count + 1))));
  2803.  
  2804.                                         string androidDate =
  2805.                                             ajObject.data;
  2806.                                         if (string.IsNullOrEmpty(startingDate) &&
  2807.                                             !string.IsNullOrEmpty(androidDate))
  2808.                                         {
  2809.                                             string[] dd = androidDate.Split(new[] { ' ' },
  2810.                                                 StringSplitOptions.RemoveEmptyEntries);
  2811.                                             string d = "04.05.2017";
  2812.                                             startingDate = currentDate;
  2813.                                             PlayerPrefs.SetString(
  2814.                                                 "date" + SaveController.Instance.data.saveIndex,
  2815.                                                 startingDate);
  2816.                                         }
  2817.                                         else
  2818.                                         {
  2819.                                             string[] dd = androidDate.Split(new[] { ' ' },
  2820.                                                 StringSplitOptions.RemoveEmptyEntries);
  2821.                                             string d = "04.05.2017";
  2822.  
  2823.                                         }
  2824.  
  2825.                                         if (firstPos)
  2826.                                         {
  2827.                                            
  2828.                                             SetZOffset(normalOffset);
  2829.                                             foreach (GameObject go in trailer)
  2830.                                                 go.transform.SetParent(null);
  2831.  
  2832.                                             SquareController.Instance.CheckAfterMove();
  2833.                                             CurveController.Instance.CheckAfterMove();
  2834.                                             ParalelsController.Instance.CheckAfterMove();
  2835.  
  2836.                                         }
  2837.                                         firstPos = false;
  2838.                                         if (needToRotate)
  2839.                                         {
  2840.                                             if (rotCor != null)
  2841.                                                 StopCoroutine(rotCor);
  2842.  
  2843.                                             if (dot > -4)
  2844.                                             {
  2845.                                                 rotCor =
  2846.                                                     StartCoroutine(LookToEuler(
  2847.                                                         NextPoint.transform.rotation,
  2848.                                                         Gz *
  2849.                                                         ((pointsDealey) *
  2850.                                                          (sectorsDealey - selectedPoints.Count + 1))));
  2851.                                                 if (trailer[0].transform.parent != null)
  2852.                                                 {
  2853.                                                     trailer[0].transform.SetParent(transform);
  2854.                                                     trailer[0].transform.localEulerAngles = Vector3.zero;
  2855.                                                 }
  2856.                                             }
  2857.                                             else
  2858.                                             {
  2859.                                                 if (trailer[0].transform.parent == null)
  2860.                                                 {
  2861.                                                     if (rotCor != null)
  2862.                                                         StopCoroutine(rotCor);
  2863.                                                     StopCoroutine(movCor);
  2864.                                                     MainRightPanel.Instance.EndDraw();
  2865.                                                     foreach (GameObject go in trailer)
  2866.                                                     {
  2867.  
  2868.                                                         go.transform.SetParent(transform);
  2869.                                                         go.transform.localEulerAngles = Vector3.zero;
  2870.                                                         StopCoroutine("SmoothChangeJoint");
  2871.                                                         //SetZOffset(0, 0);
  2872.                                                         startingRotate = trackedPoint.rotation;
  2873.                                                         StartCoroutine(SmoothChangeJoint(0,
  2874.                                                                 Gz *
  2875.                                                                 ((pointsDealey) *
  2876.                                                                  (sectorsDealey - selectedPoints.Count + 1))));
  2877.                                                         // SetZOffset(normalOffset);//SetZOffset(0, 0);
  2878.                                                         ponitCount = 0;
  2879.                                                         //transform.LookAt(NextPoint.transform);
  2880.                                                     }
  2881.                                                     isBack = true;
  2882.                                                 }
  2883.                                             }
  2884.                                         }
  2885.                                     }
  2886.                                     else
  2887.                                     {
  2888.                                         StopCoroutine(movCor);
  2889.                                     }
  2890.  
  2891.                                     /*else
  2892.                                     {
  2893.  
  2894.                                     }*/
  2895.  
  2896.                                     Points.Clear();
  2897.  
  2898.                                 }
  2899.  
  2900.  
  2901.                             }
  2902.  
  2903.  
  2904.  
  2905.                             pointsCount = 0;
  2906.                         }
  2907.                         else if (!isMoving && selectedPoints.Count == 1 &&
  2908.                                  point.transform.position != transform.position)
  2909.                         {
  2910.  
  2911.                         }
  2912.                         if (Points.Count >= 100)
  2913.                         {
  2914.                             Points.RemoveRange(0, 50);
  2915.                         }
  2916.  
  2917.                     }
  2918.                     else
  2919.                     {
  2920.                         StopCoroutine("MoveToPosition");
  2921.                     }
  2922.  
  2923.  
  2924.                 }else if (ajObject.position.x != 0 && ajObject.position.y != 0 && speed < 1 && !firstPos)
  2925.                 {
  2926.                     if (trailer[0].transform.parent == null)
  2927.                     {
  2928.                         if (rotCor != null)
  2929.                             StopCoroutine(rotCor);
  2930.                         StopCoroutine(movCor);
  2931.                         MainRightPanel.Instance.EndDraw();
  2932.                         foreach (GameObject go in trailer)
  2933.                         {
  2934.  
  2935.                             go.transform.SetParent(transform);
  2936.                             go.transform.localEulerAngles = Vector3.zero;
  2937.                             StopCoroutine("SmoothChangeJoint");
  2938.                             //SetZOffset(0, 0);
  2939.                             startingRotate = trackedPoint.rotation;
  2940.                             StartCoroutine(SmoothChangeJoint(0,
  2941.                                     Gz *
  2942.                                     ((pointsDealey) *
  2943.                                      (sectorsDealey - selectedPoints.Count + 1))));
  2944.                             // SetZOffset(normalOffset);//SetZOffset(0, 0);
  2945.                             ponitCount = 0;
  2946.                             //transform.LookAt(NextPoint.transform);
  2947.                         }
  2948.                         isBack = true;
  2949.                     }
  2950.                 }
  2951.  
  2952.                 if (sendCount == 5)
  2953.                 {
  2954. #if UNITY_EDITOR || !UNITY_WSA_10_0
  2955.                     GenerateSendData();
  2956. #endif
  2957.                     sendCount = 0;
  2958.                 }
  2959.                 sendCount++;
  2960.             }
  2961.             yield return new WaitForSeconds(Gz);
  2962.         }
  2963.     }
  2964.  
  2965.     private int forRotation = 0;
  2966.  
  2967.  
  2968.     public float minX = Mathf.Infinity;
  2969.     public float minY = Mathf.Infinity;
  2970.     public float maxX = -Mathf.Infinity;
  2971.     public float maxY = -Mathf.Infinity;
  2972.     public Quaternion startingRotate;
  2973.  
  2974.  
  2975.     private void CheckForMinMax(Vector2 pos)
  2976.     {
  2977.         if (pos.x < minX)
  2978.         {
  2979.             minX = pos.x;
  2980.         }
  2981.         if (pos.x > maxX)
  2982.         {
  2983.             maxX = pos.x;
  2984.         }
  2985.  
  2986.         if (pos.y < minY)
  2987.         {
  2988.             minY = pos.y;
  2989.         }
  2990.         if (pos.y > maxY)
  2991.         {
  2992.             maxY = pos.y;
  2993.         }
  2994.  
  2995.         PlayerPrefs.SetFloat("minX" + SaveController.Instance.data.saveIndex, minX);
  2996.         PlayerPrefs.SetFloat("maxX" + SaveController.Instance.data.saveIndex, maxX);
  2997.         PlayerPrefs.SetFloat("minY" + SaveController.Instance.data.saveIndex, minY);
  2998.         PlayerPrefs.SetFloat("maxY" + SaveController.Instance.data.saveIndex, maxY);
  2999.     }
  3000.  
  3001.     private GameObject GetFinestPosition()
  3002.     {
  3003.         float minAngle = 999;
  3004.         int selectedIndex = 0;
  3005.         for (int i = 0; i < selectedPoints.Count; i++)
  3006.         {
  3007.             var angle = AngleSigned(transform.position, selectedPoints[i].transform.position - transform.position, Vector3.up);
  3008.             if (angle > 0 && angle < minAngle)
  3009.             {
  3010.                 minAngle = angle;
  3011.                 selectedIndex = i;
  3012.             }
  3013.             else if (angle < 0 && minAngle > 0)
  3014.             {
  3015.                 minAngle = angle;
  3016.                 selectedIndex = i;
  3017.             }
  3018.             else if (angle < 0 && minAngle < 0 && angle > minAngle)
  3019.             {
  3020.                 minAngle = angle;
  3021.                 selectedIndex = i;
  3022.             }
  3023.             else if (angle == 0)
  3024.             {
  3025.                 selectedIndex = i;
  3026.             }
  3027.         }
  3028.         if (selectedIndex < selectedPoints.Count)
  3029.             return selectedPoints[selectedIndex];
  3030.         else if (selectedIndex >= selectedPoints.Count && selectedPoints.Count > 0)
  3031.         {
  3032.             return selectedPoints[0];
  3033.         }
  3034.         else if(Points.Count != 0)
  3035.         {
  3036.             return Points[Points.Count - 1];
  3037.         }
  3038.         else
  3039.         {
  3040.             return null;
  3041.         }
  3042.  
  3043.         /*float minDist = 0;
  3044.         int selectedIndex = 0;
  3045.  
  3046.  
  3047.         for (int i = 0; i < selectedPoints.Count; i++)
  3048.         {
  3049.             float dist = Vector3.Distance(NextPoint.transform.position, selectedPoints[i].transform.position);
  3050.             if (dist > minDist)
  3051.             {
  3052.                 minDist = dist;
  3053.                 selectedIndex = i;
  3054.             }
  3055.         }
  3056.         if (selectedIndex < selectedPoints.Count)
  3057.             return selectedPoints[selectedIndex];
  3058.         else if (selectedIndex >= selectedPoints.Count && selectedPoints.Count > 0)
  3059.         {
  3060.             return selectedPoints[0];
  3061.         }
  3062.         else
  3063.         {
  3064.             return Points[Points.Count - 1];
  3065.         }*/
  3066.     }
  3067.  
  3068.     private Vector3 CreateSector()
  3069.     {
  3070.         try
  3071.         {
  3072.             Dictionary<Vector2, List<GameObject>> sectors = new Dictionary<Vector2, List<GameObject>>();
  3073.             float sm = (6.278353f / 100) * (smDealey * 2);
  3074.             for (int i = Points.Count - (int)(pointsDealey); i < Points.Count; i++)
  3075.             {
  3076.                 int x = (int)(Points[i].transform.position.x * sm);
  3077.                 int z = (int)(Points[i].transform.position.z * sm);
  3078.                 Vector2 tmp = new Vector2(x, z);
  3079.                 if (sectors.ContainsKey(tmp))
  3080.                 {
  3081.                     sectors[tmp].Add(Points[i].gameObject);
  3082.                 }
  3083.                 else
  3084.                 {
  3085.                     sectors.Add(tmp, new List<GameObject>());
  3086.                     sectors[tmp].Add(Points[i].gameObject);
  3087.                 }
  3088.  
  3089.             }
  3090.             int max = 0;
  3091.             Vector2 tmpKey = Vector2.zero;
  3092.             foreach (KeyValuePair<Vector2, List<GameObject>> pair in sectors)
  3093.             {
  3094.                 if (sectors[pair.Key].Count >= max)
  3095.                 {
  3096.                     if (selectedPoints.Count == 0)
  3097.                     {
  3098.                         max = sectors.Count;
  3099.                         tmpKey = pair.Key;
  3100.                     }
  3101.                     else
  3102.                     {
  3103.                         if (Vector3.Distance(sectors[pair.Key][0].transform.position, selectedPoints[0].transform.position) > 0)
  3104.                         {
  3105.                             max = sectors.Count;
  3106.                             tmpKey = pair.Key;
  3107.                         }
  3108.                     }
  3109.                 }
  3110.             }
  3111.             var sphere = Instantiate(Sphere);
  3112.             sphere.gameObject.transform.SetParent(parent.transform, false);
  3113.  
  3114.             Vector3 pos = new Vector3((int)(sectors[tmpKey][0].transform.position.x / sm) * sm, sectors[tmpKey][0].transform.position.y, (int)(sectors[tmpKey][0].transform.position.z / sm) * sm);
  3115.  
  3116.             sphere.transform.position = pos;
  3117.             sphere.GetComponent<MeshRenderer>().material = NextPointMaterial;
  3118.             selectedPoints.Add(sphere);
  3119.  
  3120.             return sectors[tmpKey][0].transform.position;
  3121.         }
  3122.         catch (Exception ex)
  3123.         {
  3124.             return Points[Points.Count - 1].transform.position;
  3125.         }
  3126.     }
  3127.  
  3128.     public IEnumerator LookToEuler(Quaternion euler, float timeToMove)
  3129.     {
  3130.         var currentPos = transform.rotation;
  3131.         var t = 0f;
  3132.  
  3133.         while (t < 1)
  3134.         {
  3135.             t += Time.deltaTime / (timeToMove * 2);
  3136.  
  3137.             transform.rotation = Quaternion.Lerp(currentPos, euler, t);
  3138.             yield return null;
  3139.         }
  3140.     }
  3141.  
  3142.     public void ChangeFilter()
  3143.     {
  3144.         enabledFilter = !enabledFilter;
  3145.     }
  3146.  
  3147.     public IEnumerator SmoothChangeJoint(float to, float timeToMove)
  3148.     {
  3149.         if (timeToMove < 0)
  3150.             timeToMove *= -1;
  3151.         canPaint = false;
  3152.         var currentPos = trailerJoint[0].connectedAnchor.z;
  3153.         var t = 0f;
  3154.         float step = to / timeToMove * Time.deltaTime;
  3155.         float baseZ = 0;
  3156.  
  3157.  
  3158.         bool isDisabled = true;
  3159.         while (t < 1)
  3160.         {
  3161.             //stepToMove = normalDist / 6.278353f * Time.deltaTime / timeToMove;
  3162.             t += Time.deltaTime / timeToMove;
  3163.             baseZ = Mathf.Lerp(currentPos, to, t);
  3164.  
  3165.             if (to == 0)
  3166.             {
  3167.                 if (startingRotate == transform.rotation && isDisabled)
  3168.                 {
  3169.                     MainRightPanel.Instance.ContinueDraw();
  3170.                     isDisabled = false;
  3171.                 }
  3172.                 else if (startingRotate != transform.rotation)
  3173.                 {
  3174.                     if (!isDisabled)
  3175.                     {
  3176.                         MainRightPanel.Instance.EndDraw();
  3177.                     }
  3178.                 }
  3179.             }
  3180.  
  3181.             trailerJoint[0].connectedAnchor = new Vector3(0, 0, baseZ);
  3182.             yield return null;
  3183.         }
  3184.  
  3185.         if (to == 0)
  3186.         {
  3187.             MainRightPanel.Instance.EndDraw();
  3188.         }
  3189.  
  3190.     }
  3191.  
  3192.     public float stepToMove = 0;
  3193.  
  3194.     private Vector3d GetCoordinates()
  3195.     {
  3196.         float widthM = (float)SaveController.Instance.data.widthM;
  3197.         float widthSM = (float)SaveController.Instance.data.widthSM / 100;
  3198.         float delt = (widthM + widthSM) / 2;
  3199.         double xM =
  3200.                                 KMLController.xToLon(
  3201.                                 (-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).x +
  3202.                                  firstPosition.x) / 50);
  3203.         double yM =
  3204.             KMLController.zToLat(
  3205.             (-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).z +
  3206.              firstPosition.y) / 60);
  3207.  
  3208.         return new Vector3d(xM,yM);
  3209.     }
  3210.  
  3211.     private int moveCount = 0;
  3212.     public IEnumerator MoveToPosition(Transform transform, Transform prev, Vector3 position, float timeToMove)
  3213.     {
  3214.         if (moveCount < 10)
  3215.         {
  3216.             moveCount++;
  3217.         }
  3218.        
  3219.         var currentPos = transform.position;
  3220.         var t = 0f;
  3221.         float baseDist = Vector3.Distance(prev.position, position);
  3222.         if (timeToMove < 0)
  3223.             timeToMove *= -1;
  3224.         if (string.IsNullOrEmpty(PlayerPrefs.GetString("deviceSpeed")) || !IsOriginalDevice)
  3225.         {
  3226.             stepToMove = baseDist / 5.238071f * Time.deltaTime / timeToMove;
  3227.         }
  3228.         else if(!string.IsNullOrEmpty(PlayerPrefs.GetString("deviceSpeed")) && IsOriginalDevice)
  3229.         {
  3230.  
  3231.             stepToMove = baseDist / 5.238071f * Time.deltaTime / timeToMove;
  3232.  
  3233.         }
  3234.         moved = true;
  3235.         //timeToMove += timeToMove * 0.1f;
  3236.  
  3237.         float timee = 0;
  3238.         while (timee < timeToMove)
  3239.         {
  3240.             //stepToMove = normalDist / 6.278353f * Time.deltaTime / timeToMove;
  3241.             /*if (timeToMove >= 1)
  3242.             {
  3243.                 t += Time.deltaTime / timeToMove;
  3244.             }
  3245.             else
  3246.             {
  3247.                 t += Time.deltaTime / timeToMove;
  3248.             }*/
  3249.             timee += Time.deltaTime;
  3250.             t = timee / timeToMove;
  3251.  
  3252.  
  3253.             if (isBack)
  3254.             {
  3255.                 t = 1;
  3256.                 break;
  3257.             }
  3258.             if (MainRightPanel.Instance != null && MainRightPanel.Instance.Paint)
  3259.             {
  3260.                 movedDistance += stepToMove;
  3261.                 SaveController.Instance.data.distance = startingDistance + movedDistance;
  3262.                 int k = -1;
  3263.                 for (int i = 0; i < filledAreas.Count; i++)
  3264.                 {
  3265.                     if (filledAreas[i].width == (float)(MetricsWindow.Instance.metrics + ((float)MetricsWindow.Instance.sm / 100)))
  3266.                     {
  3267.                         k = i;
  3268.                         break;
  3269.                     }
  3270.                 }
  3271.  
  3272.                 if (k == -1)
  3273.                 {
  3274.                     FilledArea area = new FilledArea();
  3275.                     area.width = (float)(MetricsWindow.Instance.metrics + ((float)MetricsWindow.Instance.sm / 100));
  3276.                     filledAreas.Add(area);
  3277.                     k = filledAreas.Count - 1;
  3278.                 }
  3279.  
  3280.                 filledAreas[k].distance += stepToMove * (float)((float)TogglesPanel.Instance.workingToggles / (float)TogglesPanel.Instance.toggleCount);
  3281.                 SaveController.Instance.data.filledDistance = filledAreas[k].distance;
  3282.  
  3283.                 foreach (var drawer in MainRightPanel.Instance.controllers)
  3284.                 {
  3285.                     if(!TogglesPanel.Instance.indexes.Contains(drawer.index) && drawer.InArea)
  3286.                         drawer.CheckSquare();
  3287.                 }
  3288.             }
  3289.             SetMovedText();
  3290.  
  3291.             if (MainRightPanel.Instance.Paint)
  3292.             {
  3293.                 PlayerPrefs.SetFloat("posX" + SaveController.Instance.data.saveIndex, transform.position.x);
  3294.                 PlayerPrefs.SetFloat("posZ" + SaveController.Instance.data.saveIndex, transform.position.z);
  3295.             }
  3296.  
  3297.  
  3298.             if (!isBack)
  3299.                 transform.position = Vector3.Lerp(currentPos, position + offsetPos, t);
  3300.  
  3301.             Vector3d gpsVector3D = GetCoordinates();
  3302.             //OnlineMaps.instance.ChangePositionManualy(gpsVector3D.y, gpsVector3D.x);
  3303.             //OnlineMaps.instance.Redraw();
  3304.            
  3305.             yield return null;
  3306.         }
  3307.        
  3308.         moved = false;
  3309.     }
  3310.  
  3311.     void SetDistanceByAcc(float stepToMove)
  3312.     {
  3313.         if (MainRightPanel.Instance != null && MainRightPanel.Instance.Paint)
  3314.         {
  3315.             movedDistance += stepToMove;
  3316.             SaveController.Instance.data.distance = startingDistance + movedDistance;
  3317.             int k = -1;
  3318.             for (int i = 0; i < filledAreas.Count; i++)
  3319.             {
  3320.                 if (filledAreas[i].width == (float)(MetricsWindow.Instance.metrics + ((float)MetricsWindow.Instance.sm / 100)))
  3321.                 {
  3322.                     k = i;
  3323.                     break;
  3324.                 }
  3325.             }
  3326.  
  3327.             if (k == -1)
  3328.             {
  3329.                 FilledArea area = new FilledArea();
  3330.                 area.width = (float)(MetricsWindow.Instance.metrics + ((float)MetricsWindow.Instance.sm / 100));
  3331.                 filledAreas.Add(area);
  3332.                 k = filledAreas.Count - 1;
  3333.             }
  3334.  
  3335.             filledAreas[k].distance += stepToMove * (float)((float)TogglesPanel.Instance.workingToggles / (float)TogglesPanel.Instance.toggleCount);
  3336.             SaveController.Instance.data.filledDistance = filledAreas[k].distance;
  3337.  
  3338.             foreach (var drawer in MainRightPanel.Instance.controllers)
  3339.             {
  3340.                 if (!TogglesPanel.Instance.indexes.Contains(drawer.index) && drawer.InArea)
  3341.                     drawer.CheckSquare();
  3342.             }
  3343.         }
  3344.         SetMovedText();
  3345.  
  3346.     }
  3347.  
  3348.     private void ChangeSppedLimit()
  3349.     {
  3350.         if (SaveController.Instance.data.debugFileName != "-" || IsOriginalDevice)
  3351.         {
  3352.             if (!string.IsNullOrEmpty(PlayerPrefs.GetString("deviceSpeed")) && !isBack)
  3353.             {
  3354.                 if (speed < 3)
  3355.                 {
  3356.                     pointsDealey = 0.5f * 10;
  3357.                     sectorsDealey = 2;
  3358.  
  3359.                 }
  3360.                 else if (speed >= 3 && speed <= 8)
  3361.                 {
  3362.                     pointsDealey = 0.5f * 10;
  3363.                     sectorsDealey = 2;
  3364.                 }
  3365.                 else if (speed >= 8 && speed <= 15)
  3366.                 {
  3367.                     pointsDealey = 0.4f * 10;
  3368.                     sectorsDealey = 2;
  3369.                 }
  3370.                 else if (speed >= 15 && speed <= 25)
  3371.                 {
  3372.                     pointsDealey = 0.3f * 10;
  3373.                     sectorsDealey = 2;
  3374.                 }
  3375.                 else if (speed >= 25 && speed <= 65)
  3376.                 {
  3377.                     pointsDealey = 0.2f * 10;
  3378.                     sectorsDealey = 2;
  3379.                 }
  3380.                 else
  3381.                 {
  3382.                     pointsDealey = 0.2f * 10;
  3383.                     sectorsDealey = 2;
  3384.                 }
  3385.             }
  3386.  
  3387.         }
  3388.     }
  3389.  
  3390.     public void AddOverSquare(float square)
  3391.     {
  3392.         overSquare += square;
  3393.     }
  3394.  
  3395.     public IEnumerator SaveWork()
  3396.     {
  3397.         while (true)
  3398.         {
  3399.             yield return new WaitForSeconds(60);
  3400.             try
  3401.             {
  3402.                 SaveController.Instance.SaveData();
  3403.             }
  3404.             catch
  3405.             {
  3406.  
  3407.             }
  3408.         }
  3409.     }
  3410.  
  3411.     private void SetMovedText()
  3412.     {
  3413.         if (startingDistance + movedDistance < 1000  && !float.IsPositiveInfinity((startingDistance + movedDistance)))
  3414.         {
  3415.             movedDistanceText.text = Math.Round(startingDistance + movedDistance, 1).ToString();
  3416.             speedKMText.text = "м";
  3417.         }
  3418.         else if(startingDistance + movedDistance >= 1000 && !float.IsPositiveInfinity((startingDistance + movedDistance)))
  3419.         {
  3420.             movedDistanceText.text = (Math.Round((startingDistance + movedDistance) / 1000, 2)).ToString();
  3421.             speedKMText.text = "км";
  3422.         }
  3423.  
  3424.         float dist = 0;
  3425.         foreach (FilledArea area in filledAreas)
  3426.         {
  3427.             float tempDist = area.distance * area.width;
  3428.             if (tempDist < 0)
  3429.             {
  3430.                 tempDist *= -1;
  3431.             }
  3432.             if(!float.IsNaN(tempDist))
  3433.                 dist += tempDist;
  3434.         }
  3435.         filledDistanceText.text = (Math.Round((dist) / 10000 + startingFillingDistance, 2)).ToString();
  3436.         SaveController.Instance.data.filledDistance = (dist) / 10000 + startingFillingDistance;
  3437.         if (filledDistanceText.text == "NaN")
  3438.         {
  3439.             filledDistanceText.text = "0";
  3440.             SaveController.Instance.data.filledDistance = 0;
  3441.         }
  3442.  
  3443.  
  3444.     }
  3445.  
  3446.     private List<float> _distances = new List<float>();
  3447.     private GameObject[] LoadCoordinatesByName(string fileName, int distance)
  3448.     {
  3449.         var coords = KMLController.LoadXML(fileName);
  3450.         var pairs = KMLController.GetPairsFromLoadedKML(coords);
  3451.         if (_zeroPoint == Vector3.zero)
  3452.             _zeroPoint = coords[0];
  3453.         var newPoints = new GameObject[pairs.Count * 2];
  3454.         var parent = new GameObject(fileName);
  3455.         parent.gameObject.transform.SetParent(NextPoint.gameObject.transform.parent, false);
  3456.         for (int i = 0; i < pairs.Count; i++)
  3457.         {
  3458.             var item = pairs[i];
  3459.             var point = Instantiate(NextPoint);
  3460.             point.gameObject.transform.SetParent(parent.transform, false);
  3461.             point.transform.localRotation = NextPoint.gameObject.transform.localRotation;
  3462.             point.transform.localPosition = new Vector3(_zeroPoint.x - item.First.x, NextPoint.gameObject.transform.localPosition.y, _zeroPoint.z - item.First.z);
  3463.             //point.gameObject.SetActive(false);
  3464.             newPoints[i * 2] = point;
  3465.  
  3466.             point = Instantiate(NextPoint);
  3467.             point.gameObject.transform.SetParent(parent.transform, false);
  3468.             point.transform.localRotation = NextPoint.gameObject.transform.localRotation;
  3469.             point.transform.localPosition = new Vector3(_zeroPoint.x - item.Second.x, NextPoint.gameObject.transform.localPosition.y, _zeroPoint.z - item.Second.z);
  3470.             //point.gameObject.SetActive(false);
  3471.             newPoints[i * 2 + 1] = point;
  3472.  
  3473.             var dis = Vector3.Distance(pairs[i].First, pairs[i].Second) / distance;
  3474.             _distances.Add(dis);
  3475.             //Debug.LogError(dis);
  3476.         }
  3477.  
  3478.         NextPoint = newPoints[0];
  3479.  
  3480.         return newPoints;
  3481.     }
  3482.  
  3483.     private GameObject SkippedPoint = null;
  3484.  
  3485.     IEnumerator StartEmitor()
  3486.     {
  3487.         yield return new WaitForSeconds(0.1f);
  3488.         Particle.Play();
  3489.     }
  3490.  
  3491.     private float GetAngle()
  3492.     {
  3493.         var turnDir = (NextPoint.transform.position - transform.position);
  3494.         var rotationAngle = 0f;
  3495.         if (turnDir != Vector3.zero)
  3496.             rotationAngle = AngleAroundAxis(transform.forward, turnDir, Vector3.up);
  3497.         return rotationAngle;
  3498.     }
  3499.  
  3500.     private bool isPrevDirectionForvard = true;
  3501.     float prevAngle = 0f;
  3502.     public float speed = 0;
  3503.     private Vector3 lastPos = Vector3.zero;
  3504.  
  3505.     private float lastRotY = 0;
  3506.     private bool lastWorkState = false;
  3507.     private bool minSpeedAir = true;
  3508.     public void FixedUpdate()
  3509.     {
  3510.         if(ConstConfig.isInnerGPS)
  3511.         {
  3512.             IsConnected = true;
  3513.         }
  3514.  
  3515.         if (CheckWorkType.Instance.typeId == 8 && SquareController.Instance.newMode && SquareController.InSquare(SquareController.Instance.linePositions.ToArray(),transform.position))
  3516.         {
  3517.             if (speed > SpeedWindow.Instance.CurrentMinSpeed && speed < SpeedWindow.Instance.CurrentMaxSpeed &&
  3518.                 !MainRightPanel.Instance.Paint && !SaveController.Instance.data.isAccelerator)
  3519.             {
  3520.                 MainRightPanel.Instance.UI_OnTurnPaint(true);
  3521.             }else if ((speed < SpeedWindow.Instance.CurrentMinSpeed || speed > SpeedWindow.Instance.CurrentMaxSpeed) &&
  3522.                       MainRightPanel.Instance.Paint && !SaveController.Instance.data.isAccelerator)
  3523.             {
  3524.                 MainRightPanel.Instance.UI_OnTurnPaint(false);
  3525.             }
  3526.         }else if (CheckWorkType.Instance.typeId == 8 && !SquareController.Instance.newMode)
  3527.         {
  3528.             if ((TractorController.Instance.speed < SpeedWindow.Instance.CurrentMinSpeed ||
  3529.                      TractorController.Instance.speed > SpeedWindow.Instance.CurrentMaxSpeed))
  3530.             {
  3531.                 if (!minSpeedAir && !SaveController.Instance.data.isAccelerator)
  3532.                 {
  3533.                     MainRightPanel.Instance.UI_OnTurnPaint(false);
  3534.                     MainRightPanel.Instance.UI_OnTurnPaint(true);
  3535.                     minSpeedAir = true;
  3536.                 }
  3537.             }
  3538.             else if ((TractorController.Instance.speed > SpeedWindow.Instance.CurrentMinSpeed &&
  3539.                       TractorController.Instance.speed < SpeedWindow.Instance.CurrentMaxSpeed))
  3540.             {
  3541.                 if (minSpeedAir && !SaveController.Instance.data.isAccelerator)
  3542.                 {
  3543.                     MainRightPanel.Instance.UI_OnTurnPaint(false);
  3544.                     MainRightPanel.Instance.UI_OnTurnPaint(true);
  3545.                     minSpeedAir = false;
  3546.                 }
  3547.             }
  3548.         }
  3549.  
  3550.             if (SquareController.Instance.newMode)
  3551.         {
  3552.             bool newWorkState = SquareController.InSquare(SquareController.Instance.linePositions.ToArray(),
  3553.                 trackedPoint.position);
  3554.             if (lastWorkState != newWorkState && !SaveController.Instance.data.isAccelerator)
  3555.             {
  3556.                 MainRightPanel.Instance.UI_OnTurnPaint(false);
  3557.                 MainRightPanel.Instance.UI_OnTurnPaint(true);
  3558.             }
  3559.             lastWorkState = newWorkState;
  3560.         }
  3561.  
  3562.  
  3563.         /*Vector3 targetPostition = new Vector3(NextPoint.transform.position.x,
  3564.                                         Arrow.transform.transform.position.y,
  3565.                                         NextPoint.transform.position.z);
  3566.  
  3567.         Arrow.transform.LookAt(targetPostition);
  3568.         */
  3569.         var RotateFrontWheelTransform = RotateFrontWheels[0].transform;
  3570.         // var angle = trailer.transform.eulerAngles.y - transform.eulerAngles.y;// AngleSigned(trackedPoint.forward, transform.position - trackedPoint.position + trackedPoint.forward, trackedPoint.up);
  3571.         // trackedPoint.RotateAround(trackedPoint.position, Vector3.up, trackedPoint.position.y + angle);
  3572.  
  3573.         for (int i = 0; i < 2; i++)
  3574.         {
  3575.             // RotateFrontWheels[i].transform.RotateAround(FrontWheels[i].transform.position, Vector3.up, FrontWheels[i].transform.position.y + angle);
  3576.             //RotateFrontWheels[i].transform.localEulerAngles = new Vector3(0, 0, trackedPoint.localEulerAngles.y);
  3577.             if (CheckWorkType.Instance.typeId != 5)
  3578.             {
  3579.                 RotateFrontWheels[i].transform.eulerAngles = new Vector3(0, transform.eulerAngles.y - 180, 0);
  3580.                     // new Vector3(0,0, -angle);
  3581.             }
  3582.             //RotateFrontWheels[i].transform.LookAt(transform);
  3583.         }
  3584.         if (CheckWorkType.Instance.typeId != 5)
  3585.         {
  3586.             if (RotateFrontWheels[0].transform.localEulerAngles.x < 45)
  3587.             {
  3588.                 RotateFrontWheels[0].transform.localEulerAngles = new Vector3(45, 0, 0);
  3589.             }
  3590.             else if (RotateFrontWheels[0].transform.localEulerAngles.x > 135)
  3591.             {
  3592.                 RotateFrontWheels[0].transform.localEulerAngles = new Vector3(135, 0, 0);
  3593.             }
  3594.  
  3595.             if (RotateFrontWheels[1].transform.localEulerAngles.x < 45)
  3596.             {
  3597.                 RotateFrontWheels[1].transform.localEulerAngles = new Vector3(45, 0, 0);
  3598.             }
  3599.             else if (RotateFrontWheels[1].transform.localEulerAngles.x > 135)
  3600.             {
  3601.                 RotateFrontWheels[1].transform.localEulerAngles = new Vector3(135, 0, 0);
  3602.             }
  3603.         }
  3604.         // MoveToNextPoint();
  3605.  
  3606.         if (lastPos != transform.position)
  3607.         {
  3608.             float dist = Vector3.Distance(lastPos, transform.position);
  3609.             if (CheckWorkType.Instance.typeId != 5)
  3610.             {
  3611.                 foreach (var wheel in FrontWheels)
  3612.                     wheel.transform.Rotate(new Vector3(1, 0, 0), -(dist * 5));
  3613.                 foreach (var wheel in RearWheels)
  3614.                     wheel.transform.Rotate(new Vector3(1, 0, 0), -(dist * 4));
  3615.             }
  3616.             else
  3617.             {
  3618.                 foreach (var wheel in FrontWheels)
  3619.                     wheel.transform.Rotate(new Vector3(1, 0, 0), (dist * 5));
  3620.                 foreach (var wheel in RearWheels)
  3621.                     wheel.transform.Rotate(new Vector3(1, 0, 0), (dist * 4));
  3622.             }
  3623.  
  3624.             Move = true;
  3625.            
  3626.             //Vector3 vectorForOffset = (transform.position -lastPos).normalized;
  3627.             //GrounMaterial.mainTextureOffset = new Vector2(GrounMaterial.mainTextureOffset.x + vectorForOffset.x * Time.deltaTime / 3, GrounMaterial.mainTextureOffset.y + vectorForOffset.y * Time.deltaTime / 3);
  3628.             lastPos = transform.position;
  3629.  
  3630.             if (CheckWorkType.Instance.typeId == 7 && SquareController.Instance.isTracked)
  3631.             {
  3632.                 movedDistance += dist / 6.278354f;
  3633.                 if (startingDistance + movedDistance < 1000)
  3634.                 {
  3635.                     movedDistanceText.text = Math.Round(startingDistance + movedDistance, 1).ToString();
  3636.                     speedKMText.text = "м";
  3637.                 }
  3638.                 else
  3639.                 {
  3640.                     movedDistanceText.text = (Math.Round((startingDistance + movedDistance) / 1000, 2)).ToString();
  3641.                     speedKMText.text = "км";
  3642.                 }
  3643.             }
  3644.  
  3645.             if (CheckWorkType.Instance.typeId == 8)
  3646.             {
  3647.                 CommasGameObject.transform.localEulerAngles = new Vector3(-90,-MainTransform.eulerAngles.y,90);
  3648.                 //AirLine.SetPosition(0,new Vector3(AirPoint.transform.position.x,1,AirPoint.transform.position.z));
  3649.                 //Vector3 toVector = AirPoint.transform.forward * 10000;
  3650.                 //AirLine.SetPosition(1, new Vector3(toVector.x, 1, toVector.z));
  3651.             }
  3652.             //MapTransform.position = Arrow.transform.position;
  3653.             //MapTransform.eulerAngles = new Vector3(0, MainTransform.eulerAngles.y, 0);
  3654.         }
  3655.         else
  3656.         {
  3657.             Move = false;
  3658.         }
  3659.  
  3660.         if (SaveController.Instance.data.isAccelerator)
  3661.         {
  3662.             isMoving = true;
  3663.             Move = true;
  3664.             Vector3 accelerometer = Input.acceleration;
  3665.  
  3666.             if (Input.GetKey(KeyCode.W))
  3667.             {
  3668.                 accelerometer.z = -1;
  3669.             }
  3670.  
  3671.             if (Input.GetKey(KeyCode.A))
  3672.             {
  3673.                 accelerometer.z = -1;
  3674.                 accelerometer.x = -1;
  3675.             }
  3676.  
  3677.             if (Input.GetKey(KeyCode.D))
  3678.             {
  3679.                 accelerometer.z = -1;
  3680.                 accelerometer.x = 1;
  3681.             }
  3682.  
  3683.            
  3684.             //debugText.text = String.Format(" X: {0}\r\n Y: {1}\r\n Z: {2}", Math.Round(accelerometer.x,2), Math.Round(accelerometer.y, 2), Math.Round(accelerometer.z, 2));
  3685.  
  3686.             float yMove =(-1 * accelerometer.z) * 2;
  3687.             float zMove = yMove * (accelerometer.x * 2);
  3688.             if (CheckWorkType.Instance.typeId == 8)
  3689.             {
  3690.                 //transform.Translate(0, 0, 25 * Time.deltaTime, Space.Self);
  3691.                 transform.Translate(0, 0, yMove * 150 * Time.deltaTime, Space.Self);
  3692.                 transform.Rotate(0, zMove * 15 * Time.deltaTime, 0, Space.Self);
  3693.  
  3694.                 speed = 150 * yMove / 2;
  3695.                 if (speed < 0)
  3696.                 {
  3697.                     speed *= -1;
  3698.                 }
  3699.                 speedText.text = Math.Round(speed, 0).ToString();
  3700.             } else
  3701.             {
  3702.                 transform.Translate(0, 0, yMove * 15 * Time.deltaTime, Space.Self);
  3703.                 //transform.Translate(0, 0,  4 * Time.deltaTime, Space.Self);
  3704.                 transform.Rotate(0, zMove * 15 * Time.deltaTime, 0, Space.Self);
  3705.                 //transform.Rotate(0,  12.5f * Time.deltaTime, 0, Space.Self);
  3706.  
  3707.                 speed = 15 * yMove / 2;
  3708.                 if (speed < 0)
  3709.                 {
  3710.                     speed *= -1;
  3711.                 }
  3712.                 speedText.text = Math.Round(speed, 0).ToString();
  3713.             }
  3714.            
  3715.  
  3716.             currentDate = DateTime.Now.ToString();
  3717.             if (string.IsNullOrEmpty(startingDate))
  3718.             {
  3719.                 startingDate = currentDate;
  3720.                 PlayerPrefs.SetString( "date" + SaveController.Instance.data.saveIndex, startingDate);
  3721.             }
  3722.  
  3723.             if (lastAccPos != null && lastAccPos != Vector3.zero)
  3724.             {
  3725.                 float baseDist = Vector3.Distance(lastAccPos, transform.position) / 5.238071f;
  3726.                 stepToMove = baseDist;
  3727.                 SetDistanceByAcc(baseDist);
  3728.             }
  3729.             CheckForMinMax(new Vector2(transform.position.x,transform.position.z));
  3730.            
  3731.             lastAccPos = transform.position;
  3732.         }
  3733.        
  3734.     }
  3735.  
  3736.     private Vector3 lastAccPos;
  3737.     private bool airOnGround = true;
  3738.  
  3739.     public bool isRotation = false;
  3740.  
  3741.     private void SetAltitudeText()
  3742.     {
  3743.         if (altitude < 1000)
  3744.         {
  3745.             altitudeText.text = Math.Round(altitude, 1).ToString();
  3746.             altitudeAdditionalText.text = "м";
  3747.         }
  3748.         else
  3749.         {
  3750.             altitudeText.text = Math.Round(altitude / 1000, 1).ToString();
  3751.             altitudeAdditionalText.text = "км";
  3752.         }
  3753.     }
  3754.  
  3755.     private IEnumerator TrackAirRotation()
  3756.     {
  3757.         while (true)
  3758.         {
  3759.             if (altitude < 1000)
  3760.             {
  3761.                 altitudeText.text = Math.Round(altitude, 1).ToString();
  3762.                 altitudeAdditionalText.text = "м";
  3763.             }
  3764.             else
  3765.             {
  3766.                 altitudeText.text = Math.Round(altitude / 1000, 1).ToString();
  3767.                 altitudeAdditionalText.text = "км";
  3768.             }
  3769.  
  3770.             if (isMoving && !isBack)
  3771.             {
  3772.  
  3773.                 float angle = AngleInDeg();
  3774.  
  3775.                
  3776.  
  3777.                 float x = transform.localEulerAngles.y - MainTransform.localEulerAngles.y;
  3778.                 if (x > 45 && x <= 180)
  3779.                 {
  3780.                     x = 180 - x;
  3781.                 }
  3782.                 else if (x > 180 && x <= 360)
  3783.                 {
  3784.                     x = x - 360;
  3785.                 }
  3786.  
  3787.                 float newAngle = Mathf.LerpAngle(x, angle, 0.01f);
  3788.                 newAngle = Mathf.LerpAngle(x, newAngle, 0.001f);
  3789.                 Vector3 airVector = new Vector3(-newAngle, airship.localEulerAngles.y, airship.localEulerAngles.z);
  3790.                 airVector = GetNormalVector(airVector);
  3791.                 Vector3 lastRotation = airship.localEulerAngles;
  3792.                 float timeCourotine = 0;
  3793.                 float to = airVector.x;
  3794.                 Vector3 newVector = airship.localEulerAngles;
  3795.                 if (!airOnGround)
  3796.                 {
  3797.                     isRotation = to >= 35 || to <= -35;
  3798.                     while (timeCourotine < 1)
  3799.                     {
  3800.                         newVector.x = Mathf.LerpAngle(lastRotation.x, to, timeCourotine);
  3801.                         airship.localEulerAngles = newVector;
  3802.                         //airship.localEulerAngles = Vector3.LerpUnclamped(lastRotation,airVector, timeCourotine);
  3803.                         timeCourotine += Time.deltaTime / 2;
  3804.                         yield return new WaitForSeconds(Time.deltaTime / 2);
  3805.                     }
  3806.                 }
  3807.                 else
  3808.                 {
  3809.                     while (timeCourotine < 1)
  3810.                     {
  3811.                         newVector.x = Mathf.LerpAngle(lastRotation.x, 0, timeCourotine);
  3812.                         airship.localEulerAngles = newVector;
  3813.                         //airship.localEulerAngles = Vector3.LerpUnclamped(lastRotation,airVector, timeCourotine);
  3814.                         timeCourotine += Time.deltaTime / 2;
  3815.                         yield return new WaitForSeconds(Time.deltaTime / 2);
  3816.                     }
  3817.                 }
  3818.                 if (speed > SpeedWindow.Instance.LandingSpeed && airOnGround)
  3819.                 {
  3820.                     float fromY = -10;
  3821.                     float toY = 31;
  3822.                     float timeToUp = 0;
  3823.                     Vector3 airPosition = airship.localPosition;
  3824.                     while (timeToUp < 1)
  3825.                     {
  3826.                         altitude = Mathf.Lerp(148, 163, timeToUp);
  3827.                         SetAltitudeText();
  3828.                         airPosition.y = Mathf.Lerp(fromY, toY, timeToUp);
  3829.                         airship.localPosition = airPosition;
  3830.                         timeToUp += Time.deltaTime / 4;
  3831.                         yield return new WaitForSeconds(Time.deltaTime / 2);
  3832.  
  3833.                     }
  3834.                     airOnGround = false;
  3835.                 }
  3836.                 else if (speed < SpeedWindow.Instance.LandingSpeed && !airOnGround)
  3837.                 {
  3838.                     float fromY = 31;
  3839.                     float toY = -10;
  3840.                     float timeToUp = 0;
  3841.                     Vector3 airPosition = airship.localPosition;
  3842.                     airOnGround = true;
  3843.                     while (timeToUp < 1)
  3844.                     {
  3845.                         altitude = Mathf.Lerp(163,148 , timeToUp);
  3846.                         SetAltitudeText();
  3847.                         airPosition.y = Mathf.Lerp(fromY, toY, timeToUp);
  3848.                         airship.localPosition = airPosition;
  3849.                         timeToUp += Time.deltaTime / 4;
  3850.                         yield return new WaitForSeconds(Time.deltaTime / 2);
  3851.                     }
  3852.                    
  3853.                 }
  3854.  
  3855.  
  3856.             }
  3857.             yield return new WaitForSeconds(Time.deltaTime);
  3858.         }
  3859.     }
  3860.  
  3861.     private Vector3 GetNormalVector(Vector3 airVector)
  3862.     {
  3863.         if (airVector.x > 45 && airVector.x <= 180)
  3864.         {
  3865.             airVector.x = 180 - airVector.x;
  3866.         }
  3867.         else if (airVector.x > 180 && airVector.x <= 360)
  3868.         {
  3869.             airVector.x = airVector.x - 360;
  3870.         }
  3871.  
  3872.         if (airVector.x < -45)
  3873.         {
  3874.             airVector.x = -45;
  3875.         }
  3876.         else if (airVector.x > 45)
  3877.         {
  3878.             airVector.x = 45;
  3879.         }
  3880.  
  3881.         if (airVector.y > 45 && airVector.y <= 180)
  3882.         {
  3883.             airVector.y = 180 - airVector.y;
  3884.         }
  3885.         else if (airVector.y > 180 && airVector.y <= 360)
  3886.         {
  3887.             airVector.y = airVector.y - 360;
  3888.         }
  3889.  
  3890.         if (airVector.y < -45)
  3891.         {
  3892.             airVector.y = -45;
  3893.         }
  3894.         else if (airVector.y > 45)
  3895.         {
  3896.             airVector.y = 45;
  3897.         }
  3898.  
  3899.  
  3900.         return airVector;
  3901.     }
  3902.  
  3903.     private float GetAngleBetweenAirShip()
  3904.     {
  3905.         Vector3 dir = MainTransform.position - transform.position;
  3906.         dir = MainTransform.InverseTransformDirection(dir);
  3907.         return Mathf.Atan2(dir.y, dir.x) * Mathf.Rad2Deg;
  3908.     }
  3909.  
  3910.     public float AngleInDegForCombine()
  3911.     {
  3912.         return AngleInRad(MainTransform.position, transform.position + transform.forward) * 180 / Mathf.PI;
  3913.     }
  3914.  
  3915.     public float AngleInRad(Vector3 vec1, Vector3 vec2)
  3916.     {
  3917.         return Mathf.Atan2(vec2.y - vec1.y, vec2.x - vec1.x);
  3918.     }
  3919.  
  3920.     //This returns the angle in degrees
  3921.     public float AngleInDeg()
  3922.     {
  3923.         return AngleInRad(MainTransform.position, transform.position) * 180 / Mathf.PI;
  3924.     }
  3925.  
  3926.     bool Move = false;
  3927.  
  3928.     float currentTime = 0;
  3929.  
  3930.  
  3931.  
  3932.     private float CalculateDistance()
  3933.     {
  3934.         float angle = Mathf.DeltaAngle(Mathf.Atan2(transform.position.x, transform.position.z) * Mathf.Rad2Deg,
  3935.                                  Mathf.Atan2(NextPoint.transform.position.x, NextPoint.transform.position.z) * Mathf.Rad2Deg);
  3936.         return angle;
  3937.     }
  3938.  
  3939.     public static float AngleAroundAxis(Vector3 dirA, Vector3 dirB, Vector3 axis)
  3940.     {
  3941.         // Project A and B onto the plane orthogonal target axis
  3942.         dirA = dirA - Vector3.Project(dirA, axis);
  3943.         dirB = dirB - Vector3.Project(dirB, axis);
  3944.  
  3945.         // Find (positive) angle between A and B
  3946.         float angle = Vector3.Angle(dirA, dirB);
  3947.  
  3948.         // Return angle multiplied with 1 or -1
  3949.         return angle * (Vector3.Dot(axis, Vector3.Cross(dirA, dirB)) < 0 ? -1 : 1);
  3950.     }
  3951.  
  3952.     public static float AngleSigned(Vector3 v1, Vector3 v2, Vector3 n)
  3953.     {
  3954.         return Mathf.Atan2(
  3955.             Vector3.Dot(n, Vector3.Cross(v1, v2)),
  3956.             Vector3.Dot(v1, v2)) * Mathf.Rad2Deg;
  3957.     }
  3958.  
  3959.     public void ChangeLight()
  3960.     {
  3961.         if (PlayerPrefs.GetInt("VelestorDevice") == 1)
  3962.         {
  3963.             light.SetActive(!light.activeSelf);
  3964.             if (CheckWorkType.Instance.typeId != 8)
  3965.             {
  3966.                 carLightTexture.SetActive(!light.activeSelf);
  3967.             }
  3968.             lights.SetActive(!light.activeSelf);
  3969.             DayNightSwitcher.Instance.SetColors(!carLightTexture.activeSelf);
  3970.         }
  3971.         else
  3972.         {
  3973.             MainGUI.Instance.StartShowCantOpen();
  3974.         }
  3975.     }
  3976.  
  3977.     public void AddParallelPoint()
  3978.     {
  3979.         ParalelsController.Instance.SetPosition(transform);
  3980.     }
  3981.  
  3982.     private void OnTriggerEnter(Collider col)
  3983.     {
  3984.         if (col.tag == "Lines")
  3985.         {
  3986.             ParalelsController.Instance.ChangeLines(col.gameObject);
  3987.         }
  3988.         else if (col.tag == "Curves")
  3989.         {
  3990.             if (col.gameObject.transform.parent != null)
  3991.             {
  3992.                 CurveController.Instance.ResetCurves(col.gameObject.transform.parent.gameObject);
  3993.                 CurveController.Instance.SetTrackedPoint(col.gameObject);
  3994.             }
  3995.         }else if (col.tag == "Areas")
  3996.         {
  3997.             //lastArea = col;
  3998.         }
  3999.     }
  4000.  
  4001.     public void ChangeBTMode()
  4002.     {
  4003.         if (gpsActivityJavaClass != null)
  4004.         {
  4005.             string speedMessage = gpsActivityJavaClass.CallStatic<string>("ChangeMode");
  4006.         }
  4007.     }
  4008. }
  4009.  
  4010. [Serializable]
  4011. public class FilledArea
  4012. {
  4013.     public float distance = 0;
  4014.     public float width = 0;
  4015. }
RAW Paste Data
Top