API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Apr 24th, 2017
83
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 129.90 KB | None | 0 0
raw download clone embed print report
  1. using UnityEngine;
  2. using System.Collections;
  3. using System.Collections.Generic;
  4. using System;
  5. using System.Linq;
  6. //using DG.Tweening;
  7. using UnityEngine.UI;
  8. using SmartLocalization;
  9.  
  10. #if !UNITY_EDITOR && UNITY_WSA
  11. using UnityBluetoothLibrary;
  12. #endif
  13.  
  14.  
  15. public class TractorController : MonoBehaviour
  16. {
  17.     public GameObject Arrow;
  18.     public List<GameObject> trailer;
  19.     public Transform trackedPoint;
  20.     public Transform trackedPointRotation;
  21.     public GameObject loadingScreen;
  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.     private 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 Transform MainTransform;
  113.     public Transform airPropeller;
  114.  
  115.     public Material GrounMaterial;
  116.     public GameObject GroundGameObject;
  117.     private List<float> speeds = new List<float>();
  118.     private int minSpeed = 0;
  119.     private int maxSpeed = 0;
  120.  
  121.     //Combine
  122.     public Transform CombineTransform;
  123.     public GameObject CombineLeftRear;
  124.     public GameObject CombineRightRear;
  125.     public GameObject CombineLeftFront;
  126.     public GameObject CombineRightFront;
  127.     public float altOffset = 0;
  128.  
  129.     public float overSquare = 0;
  130.  
  131.     public GameObject CalibrationWindow;
  132.     private Vector3 offsetPos = Vector3.zero;
  133.     public Vector3 lastPositionSave = Vector3.zero;
  134.     public Collider lastArea;
  135.     public bool isContinue = false;
  136.  
  137.     public bool IsOriginalDevice = false;
  138.  
  139. #if !UNITY_EDITOR && UNITY_WSA_10_0
  140.     private UnityBluetooth uBluetooth;
  141.  
  142. #endif
  143.     void Awake()
  144.     {
  145.         if (PlayerPrefs.HasKey("lang"))
  146.         {
  147.             LanguageManager.Instance.ChangeLanguage(PlayerPrefs.GetString("lang"));
  148.         }
  149.         else
  150.         {
  151.             SmartCultureInfo deviceCulture = LanguageManager.Instance.GetDeviceCultureIfSupported();
  152.             if (deviceCulture != null)
  153.             {
  154.                 LanguageManager.Instance.ChangeLanguage(deviceCulture);
  155.             }
  156.             else
  157.             {
  158.                 LanguageManager.Instance.ChangeLanguage("ru");
  159.             }
  160.         }
  161.         if (SaveController.Instance.data.startingPos != Vector2.zero)
  162.         {
  163.             isContinue = true;
  164.             lastPositionSave = new Vector3(PlayerPrefs.GetFloat("posX" + SaveController.Instance.data.saveIndex), transform.position.y, PlayerPrefs.GetFloat("posZ" + SaveController.Instance.data.saveIndex));
  165.  
  166.         }
  167.  
  168.         Instance = this;
  169.     }
  170.  
  171.     void Start()
  172.     {
  173.         if (SaveController.Instance.data.startingPos != Vector2.zero)
  174.         {
  175.             CalibrationWindow.SetActive(true);
  176.             isContinue = true;
  177.         }
  178.         Invoke("AfterStart", 1);
  179.         IsOriginalDevice = PlayerPrefs.GetInt("VelestorDevice") == 1;
  180.         //LoadCoordinatesByName("10m", 10);
  181.         mainCamera = GameObject.FindGameObjectWithTag("Camera");
  182.     }
  183.  
  184.     private void AfterStart()
  185.     {
  186.         llastTimestamp = new List<double>();
  187.         SaveController.Instance.TryToLoad();
  188.         movedDistance = SaveController.Instance.data.distance;
  189.         filledDistance = SaveController.Instance.data.filledDistance;
  190.         startingDistance = movedDistance;
  191.         startingFillingDistance = filledDistance;
  192.         filledDistanceText.text = (Math.Round((startingFillingDistance), 2)).ToString();
  193.         movedDistance = 0;
  194.         filledDistance = 0;
  195.         SetMovedText();
  196.         parent = new GameObject("test");
  197.         parent.gameObject.transform.SetParent(NextPoint.gameObject.transform.parent, false);
  198.         SetDebugValues();
  199.  
  200.         if (PlayerPrefs.GetInt("VelestorDevice") == 0)
  201.         {
  202.             mainCamera = MouseOrbitImproved.Instance.twoDCamera;
  203.         }
  204.  
  205.         if (SaveController.Instance.data.startingPos != Vector2.zero)
  206.         {
  207.             firstPosition = SaveController.Instance.data.startingPos;
  208.             startingDate = PlayerPrefs.GetString("date" + SaveController.Instance.data.saveIndex);
  209.         }
  210.  
  211.         if (CheckWorkType.Instance.typeId == 8)
  212.         {
  213.             StartCoroutine(TrackAirRotation());
  214.             //loadingScreen.transform.localPosition = new Vector3(loadingScreen.transform.localPosition.x, 11,
  215.              //   loadingScreen.transform.localPosition.z);
  216.  
  217.         }
  218.         else
  219.         {
  220.             //light.SetActive(true);
  221.             lightAir.SetActive(false);
  222.  
  223.         }
  224.  
  225.         if (CheckWorkType.Instance.typeId == 5)
  226.         {
  227.             mainCamera = MouseOrbitImproved.Instance.twoDCamera;
  228.             RotateFrontWheels[0] = CombineLeftFront;
  229.             RotateFrontWheels[1] = CombineRightFront;
  230.             FrontWheels[0] = CombineLeftFront;
  231.             FrontWheels[1] = CombineRightFront;
  232.             RearWheels[0] = CombineLeftRear;
  233.             RearWheels[1] = CombineRightRear;
  234.             float nowSize = (float) (MetricsWindow.Instance.metrics + ((float) MetricsWindow.Instance.sm / 100)) - 4;
  235.             nowSize *= 10;
  236.             MouseOrbitImproved.Instance.distance += nowSize;
  237.         }
  238.  
  239.         ScreenshotCamera.gameObject.SetActive(false);
  240.         forGoogleString = PlayerPrefs.GetString("map" + SaveController.Instance.data.saveIndex);
  241.         forKML = PlayerPrefs.GetString("kml" + SaveController.Instance.data.saveIndex);
  242.         string mac = PlayerPrefs.GetString("mac");
  243.         string pin = PlayerPrefs.GetString("pin");
  244.         string deviceName = PlayerPrefs.GetString("device");
  245. #if UNITY_ANDROID && !UNITY_EDITOR
  246.         AndroidJNI.AttachCurrentThread();
  247.  
  248.         if (SaveController.Instance.gpsActivityJavaClass == null)
  249.         {
  250.             using (var javaUnityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
  251.             {
  252.                 using (var currentActivity = javaUnityPlayer.GetStatic<AndroidJavaObject>("currentActivity"))
  253.                 {
  254.                     gpsActivityJavaClass = new AndroidJavaObject("com.velestor.tractor.GPSTest", currentActivity);
  255.                     SaveController.Instance.gpsActivityJavaClass = gpsActivityJavaClass;
  256.                 }
  257.             }
  258.         }
  259.         else
  260.         {
  261.             gpsActivityJavaClass = SaveController.Instance.gpsActivityJavaClass;
  262.         }
  263.          string test = gpsActivityJavaClass.CallStatic<string>("SetAdress", mac, pin, deviceName);
  264. #endif
  265.  
  266.  
  267.         if (SaveController.Instance.data.debugFileName == "-")
  268.         {
  269.             loadingScreen.SetActive(true);
  270.             StartCoroutine(GetPositions());
  271.             StartCoroutine(GetPositionsFromBluetooth());
  272.         }
  273.         if (SaveController.Instance.data.debugFileName != "-")
  274.         {
  275.             isDemo = true;
  276. #if UNITY_EDITOR || UNITY_WSA
  277.             StartCoroutine(GetPositions());
  278. #endif
  279.             StartCoroutine(GetPositionsFromNMEA());
  280.         }
  281.  
  282. #if !UNITY_EDITOR && UNITY_WSA_10_0
  283.         uBluetooth = new UnityBluetooth();
  284.  
  285.         uBluetooth.StartBT (mac, pin, deviceName);
  286. #endif
  287.  
  288.         //string test = gpsActivityJavaClass.CallStatic<string>("SetAdress", "55:7D:C3:6D:62:61", "0183","Smart watch");
  289.         //btText.text = test;
  290.         //transform.position = new Vector3(NextPoint.transform.position.x, gameObject.transform.position.y, NextPoint.transform.position.z);
  291.  
  292.     }
  293.  
  294.     private bool isCalibrated = false;
  295.  
  296.     public void Calibrate()
  297.     {
  298.         if (lastArea != null && isContinue && !isCalibrated)
  299.         {
  300.             if (movCor != null)
  301.             {
  302.                 StopCoroutine(movCor);
  303.             }
  304.             List<Vector3> vert = ((MeshCollider) lastArea).sharedMesh.vertices.ToList();
  305.             Vector3 start = (vert[0] + vert[1]) / 2;
  306.             Vector3 end = (vert[vert.Count - 1] + vert[vert.Count - 2]) / 2;
  307.             if (Vector3.Distance(start, transform.position) > Vector3.Distance(end, transform.position))
  308.             {
  309.                 MoveTractor(new Vector3(end.x,transform.position.y,end.z));
  310.             }
  311.             else
  312.             {
  313.                 MoveTractor(new Vector3(start.x, transform.position.y, start.z));
  314.             }
  315.             isCalibrated = true;
  316.         }
  317.         CalibrationWindow.SetActive(false);
  318.     }
  319.  
  320.     private void MoveTractor(Vector3 to)
  321.     {
  322.         GameObject[] areas = GameObject.FindGameObjectsWithTag("Areas");
  323.  
  324.         MainTransform.SetParent(transform);
  325.         //transform.position = to + transform.forward *((-MainTransform.localPosition.z) * 6.278354f);
  326.         MainTransform.localEulerAngles = Vector3.zero;
  327.         MainTransform.localPosition = new Vector3(0, MainTransform.localPosition.y, MainTransform.localPosition.z);
  328.  
  329.         foreach (var obj in areas)
  330.         {
  331.             obj.transform.position = obj.transform.position + ((transform.position - to) - transform.forward * ((-MainTransform.localPosition.z) * 6.278354f));
  332.             if (obj.transform.parent != null)
  333.             {
  334.                 obj.transform.localPosition = Vector3.zero;
  335.             }
  336.         }
  337.  
  338.         MainTransform.SetParent(null);
  339.  
  340.  
  341.         Points.Clear();
  342.         pointsCount = 0;
  343.         selectedPoints.Clear();
  344.         ponitCount = 0;
  345.     }
  346.  
  347.     private void SetDebugValues()
  348.     {
  349.         SaveController.Instance.needToSave = true;
  350.         if (CheckWorkType.Instance.typeId != 5)
  351.         {
  352.             SetZOffset(SaveController.Instance.data.zOffset + (float) SaveController.Instance.data.zSMOffset / 100);
  353.         }
  354.         else
  355.         {
  356.             SetZOffset(4);
  357.         }
  358.         if (SaveController.Instance.data.debugData.pointsDealey == 1 && SaveController.Instance.data.debugData.sectorDealey == 1)
  359.         {
  360.             SaveController.Instance.data.debugData.sectorDealey = 2;
  361.             SaveController.Instance.data.debugData.pointsDealey = 0.5f;
  362.         }
  363.  
  364.         pointsDealey = SaveController.Instance.data.debugData.pointsDealey * 10;
  365.         sectorsDealey = SaveController.Instance.data.debugData.sectorDealey;
  366.         speedLimit = SaveController.Instance.data.debugData.minSpeed;
  367.         smDealey = SaveController.Instance.data.overlapM;
  368.  
  369.  
  370.  
  371.         minX = PlayerPrefs.GetFloat("minX" + SaveController.Instance.data.saveIndex);
  372.         maxX = PlayerPrefs.GetFloat("maxX" + SaveController.Instance.data.saveIndex);
  373.         minY = PlayerPrefs.GetFloat("minY" + SaveController.Instance.data.saveIndex);
  374.         maxY = PlayerPrefs.GetFloat("maxY" + SaveController.Instance.data.saveIndex);
  375.  
  376.         if (SaveController.Instance.data.isNewSave)
  377.         {
  378.             SaveController.Instance.data.isNewSave = false;
  379.             SaveController.Instance.InsertShortSave(SaveController.Instance.data);
  380.         }
  381.         QualitySettings.vSyncCount = 0;  // VSync must be disabled
  382.         Application.targetFrameRate = 30;
  383.     }
  384.  
  385.     public void SetOverlapSM(int sm)
  386.     {
  387.         smDealey = sm;
  388.     }
  389.  
  390.     private float normalOffset = 0;
  391.  
  392.     public void SetZOffset(float offset, float plus = 1)
  393.     {
  394.         if (plus == 1)
  395.         {
  396.             normalOffset = offset;
  397.             foreach (HingeJoint joint in trailerJoint)
  398.                 joint.anchor = new Vector3(0, 0, -0.5f);
  399.         }
  400.         else if (plus == 0)
  401.         {
  402.             foreach (HingeJoint joint in trailerJoint)
  403.                 joint.anchor = new Vector3(0, 0, 0);
  404.         }
  405.  
  406.         foreach (HingeJoint joint in trailerJoint)
  407.             joint.connectedAnchor = new Vector3(0, 0, (offset + plus));
  408.     }
  409.  
  410.     void OnDestroy()
  411.     {
  412.         SaveController.Instance.needToSave = false;
  413. #if !UNITY_EDITOR && UNITY_WSA_10_0
  414.         uBluetooth.StopTimer();
  415.  
  416.         string Phone =uBluetooth.Phone;
  417.  
  418.         for (int i = kmlRightList.Count - 1; i >= 0; i--)
  419.         {
  420.             forKMLRight += kmlRightList[i];
  421.         }
  422.         PlayerPrefs.SetString("endDate" + SaveController.Instance.data.saveIndex, currentDate);
  423.         PlayerPrefs.SetString("kml" + SaveController.Instance.data.saveIndex, forKMLLeft + forKMLRight);
  424.         PlayerPrefs.SetString("phone" + SaveController.Instance.data.saveIndex, Phone);
  425.         PlayerPrefs.SetString("phoneName" + SaveController.Instance.data.saveIndex, uBluetooth.friendlyName);
  426.         if (!string.IsNullOrEmpty(forKMLLeft))
  427.         {
  428.             DownloadController.Instance.StartSendWork(SaveController.Instance.data.saveIndex, startingDate, currentDate, forKMLLeft + forKMLRight, SaveController.Instance.data.adress,
  429.             SaveController.Instance.data.description, SaveController.Instance.data.user, SaveController.Instance.data.type,
  430.             ((float)((float)SaveController.Instance.data.widthM + (float)SaveController.Instance.data.widthSM / 100)).ToString(), SaveController.Instance.data.distance.ToString(),
  431.             SaveController.Instance.data.filledDistance.ToString(), SaveController.Instance.data.square.ToString(),
  432.             "123", uBluetooth.friendlyName, SystemInfo.deviceUniqueIdentifier, Phone,false,SaveController.Instance.data);
  433.  
  434.         }
  435.         if (!string.IsNullOrEmpty(kmlSquare))
  436.         {
  437.             PlayerPrefs.SetString("square" + SaveController.Instance.data.saveIndex, kmlSquare + kmlStartSquare);
  438.             DownloadController.Instance.StartSendWork(SaveController.Instance.data.saveIndex, currentDate, kmlSquare + kmlStartSquare, SaveController.Instance.data.square.ToString(), SaveController.Instance.data.adress,
  439.                 SaveController.Instance.data.description, SaveController.Instance.data.user, SaveController.Instance.data.type,
  440.                 ((float)((float)SaveController.Instance.data.widthM + (float)SaveController.Instance.data.widthSM / 100)).ToString(), SaveController.Instance.data.distance.ToString(),
  441.                 SaveController.Instance.data.filledDistance.ToString(), SaveController.Instance.data.square.ToString(),
  442.                 "", SystemInfo.deviceModel, SystemInfo.deviceUniqueIdentifier, Phone, true,SaveController.Instance.data);
  443.         }
  444.  
  445. #else
  446.         List<string> polygonsList = new List<string>();
  447.         for (int i = kmlRightList.Count - 1; i >= 0; i--)
  448.         {
  449.             forKMLRight += kmlRightList[i];
  450.         }
  451.         PlayerPrefs.SetString("overlapSquare"+SaveController.Instance.data.saveIndex, overSquare.ToString());
  452.         PlayerPrefs.SetString("endDate" + SaveController.Instance.data.saveIndex, currentDate);
  453.         PlayerPrefs.SetString("kml" + SaveController.Instance.data.saveIndex, forKMLLeft + forKMLRight);
  454.         PlayerPrefs.SetString("gpx" + SaveController.Instance.data.saveIndex, gpxString);
  455.         PlayerPrefs.SetInt("minSpeed" + SaveController.Instance.data.saveIndex, minSpeed);
  456.         PlayerPrefs.SetInt("maxSpeed" + SaveController.Instance.data.saveIndex, maxSpeed);
  457.         string Phone = gpsActivityJavaClass.CallStatic<string>("GetPhone");
  458.         PlayerPrefs.SetString("phone" + SaveController.Instance.data.saveIndex, Phone);
  459.  
  460.         if (!string.IsNullOrEmpty(forKMLLeft))
  461.         {
  462.             float averageSpeed = 0;
  463.             for (int i = 0; i < speeds.Count; i++)
  464.             {
  465.                 averageSpeed += speeds[i];
  466.             }
  467.             averageSpeed /= speeds.Count;
  468.             PlayerPrefs.SetFloat("averageSpeed" + SaveController.Instance.data.saveIndex, averageSpeed);
  469.             DownloadController.Instance.StartSendWork(SaveController.Instance.data.saveIndex, startingDate, currentDate, forKMLLeft + forKMLRight, SaveController.Instance.data.adress,
  470.                 SaveController.Instance.data.description, SaveController.Instance.data.user, SaveController.Instance.data.type,
  471.                 ((float)((float)SaveController.Instance.data.widthM + (float)SaveController.Instance.data.widthSM / 100)).ToString(), SaveController.Instance.data.distance.ToString(),
  472.                 SaveController.Instance.data.filledDistance.ToString(), SaveController.Instance.data.square.ToString(),
  473.                 Network.player.ipAddress, SystemInfo.deviceModel, SystemInfo.deviceUniqueIdentifier, Phone, false, SaveController.Instance.data,false,gpxString,minSpeed,maxSpeed,averageSpeed);
  474.  
  475.         }
  476.  
  477.         if (!string.IsNullOrEmpty(kmlSquare))
  478.         {
  479.             PlayerPrefs.SetString("square" + SaveController.Instance.data.saveIndex, kmlSquare + kmlStartSquare);
  480.             DownloadController.Instance.StartSendWork(SaveController.Instance.data.saveIndex, currentDate, kmlSquare + kmlStartSquare, SaveController.Instance.data.square.ToString(), SaveController.Instance.data.adress,
  481.                 SaveController.Instance.data.description, SaveController.Instance.data.user, SaveController.Instance.data.type,
  482.                 ((float)((float)SaveController.Instance.data.widthM + (float)SaveController.Instance.data.widthSM / 100)).ToString(), SaveController.Instance.data.distance.ToString(),
  483.                 SaveController.Instance.data.filledDistance.ToString(), SaveController.Instance.data.square.ToString(),
  484.                 Network.player.ipAddress, SystemInfo.deviceModel, SystemInfo.deviceUniqueIdentifier, Phone, true, SaveController.Instance.data);
  485.         }
  486.  
  487.         gpsActivityJavaClass.CallStatic<string>("UnpairBt");
  488. #endif
  489.     }
  490.  
  491.     public void SavePositions()
  492.     {
  493.         foreach (var control in MainRightPanel.Instance.controllers)
  494.         {
  495.             control.EndDrawLine();
  496.         }
  497.     }
  498.  
  499.     private string ScreenShotName(int width, int height)
  500.     {
  501.         return string.Format("{0}/screenshots/screen_{1}x{2}_{3}.png",
  502.                              Application.dataPath,
  503.                              width, height,
  504.                              System.DateTime.Now.ToString("yyyy-MM-dd_HH-mm-ss"));
  505.     }
  506.  
  507.     private void RenderNormalCamera()
  508.     {
  509.         if (MouseOrbitImproved.Instance.twoDCamera.activeSelf)
  510.         {
  511.             MouseOrbitImproved.Instance.twoDCamera.GetComponent<Camera>().Render();
  512.         }
  513.         else
  514.         {
  515.             MouseOrbitImproved.Instance.mCamera.GetComponent<Camera>().Render();
  516.         }
  517.  
  518.     }
  519.  
  520.     public void GetScreenshot()
  521.     {
  522.         try
  523.         {
  524.  
  525.  
  526.             SquareController.Instance.CheckInFinish();
  527.             //ScreenshotCamera.gameObject.SetActive(true);
  528.             ScreenshotCamera.transform.position = GetScreenshotPosition();
  529.             ScreenshotCamera.orthographicSize = GetOrthographicSize();
  530.             if (ScreenshotCamera.orthographicSize == 0)
  531.                 ScreenshotCamera.orthographicSize = 100;
  532.             if (ScreenshotCamera.orthographicSize <= 200)
  533.                 ScreenshotCamera.orthographicSize = 250;
  534.             RenderTexture rt = new RenderTexture(Screen.width, Screen.height, 24);
  535.             ScreenshotCamera.targetTexture = rt;
  536.             Texture2D screenShot = new Texture2D(Screen.width, Screen.height, TextureFormat.ARGB32, false);
  537.             ScreenshotCamera.Render();
  538.             //RenderNormalCamera();
  539.             RenderTexture.active = rt;
  540.             screenShot.ReadPixels(new Rect(0, 0, Screen.width, Screen.height), 0, 0);
  541.             ScreenshotCamera.targetTexture = null;
  542.             RenderTexture.active = null; // JC: added to avoid errors
  543.  
  544.             byte[] bytes = screenShot.EncodeToPNG();
  545.             string filename = Convert.ToBase64String(bytes);
  546.             SaveController.Instance.InsertSmallScreenshot(SaveController.Instance.data.saveIndex.ToString(), filename);
  547.             GetBigScreenshot();
  548.         }
  549.         catch (Exception ex)
  550.         {
  551.             PromptWindow.Instance._async.allowSceneActivation = true;
  552.         }
  553.     }
  554.  
  555.     private void GenerateSendData()
  556.     {
  557.         string toSend = "$VT,";
  558.         if (IndicatorPanel.Instance.metersText.text != "0")
  559.         {
  560.             if (speed > speedLimit)
  561.             {
  562.                 if (IndicatorPanel.Instance.arrow.localEulerAngles.z > 180)
  563.                 {
  564.                     toSend += "+" + IndicatorPanel.Instance.metersText.text;
  565.                 }
  566.                 else
  567.                 {
  568.                     toSend += "-" + IndicatorPanel.Instance.metersText.text;
  569.                 }
  570.             }
  571.             else
  572.             {
  573.                 toSend += "0";
  574.             }
  575.         }
  576.         else
  577.         {
  578.             toSend += IndicatorPanel.Instance.metersText.text;
  579.         }
  580.  
  581.         if (!MainRightPanel.Instance.Paint || speed < speedLimit)
  582.         {
  583.  
  584.             toSend += ",0,0,0,0,0,0,0,0,0";
  585.             float width = (float)SaveController.Instance.data.widthM + (float)SaveController.Instance.data.widthSM / 100;
  586.             float side = (float)SaveController.Instance.data.xOffset + (float)SaveController.Instance.data.xSMOffset / 100;
  587.             float distanceAntena = (float)SaveController.Instance.data.zOffset + (float)SaveController.Instance.data.zSMOffset / 100;
  588.             string additional = "," + (int)speed + "," + width + "," + distanceAntena + ",";
  589.             if (side > 0)
  590.             {
  591.                 additional += "+" + side;
  592.             }
  593.             else
  594.             {
  595.                 additional += side;
  596.             }
  597.             toSend += additional;
  598.  
  599.             toSend += "*";
  600.         }
  601.         else
  602.         {
  603.             for (int i = 0; i < 9; i++)
  604.             {
  605.                 if (i < TogglesPanel.Instance.toggleCount && TogglesPanel.Instance.toggleCount != 1)
  606.                 {
  607.                     toSend += ",";
  608.                     if (TogglesPanel.Instance.leftOutlines[i].IsWorking)
  609.                     {
  610.                         toSend += "1";
  611.                     }
  612.                     else
  613.                     {
  614.                         toSend += "0";
  615.                     }
  616.                 }
  617.                 else if (i < TogglesPanel.Instance.toggleCount && TogglesPanel.Instance.toggleCount == 1)
  618.                 {
  619.                     toSend += ",1";
  620.                 }
  621.                 else
  622.                 {
  623.                     toSend += ",0";
  624.                 }
  625.             }
  626.             float width = (float)SaveController.Instance.data.widthM + (float)SaveController.Instance.data.widthSM / 100;
  627.             float side = (float)SaveController.Instance.data.xOffset + (float)SaveController.Instance.data.xSMOffset / 100;
  628.             float distanceAntena = (float)SaveController.Instance.data.zOffset + (float)SaveController.Instance.data.zSMOffset / 100;
  629.             string additional = "," + (int)speed + "," + width + "," + distanceAntena + ",";
  630.             if (side > 0)
  631.             {
  632.                 additional += "+" + side;
  633.             }
  634.             else
  635.             {
  636.                 additional += side;
  637.             }
  638.             toSend += additional;
  639.  
  640.             toSend += "*";
  641.         }
  642.  
  643.         toSend += getChecksum(toSend) + "\r\n";
  644.  
  645. #if UNITY_EDITOR || !UNITY_WSA_10_0
  646.             if (gpsActivityJavaClass != null && PlayerPrefs.GetInt("VelestorDevice") == 1 &&
  647.                 PlayerPrefs.GetInt("control") == 1)
  648.             {
  649.                 gpsActivityJavaClass.CallStatic<string>("SendData", toSend);
  650.             }
  651. #else
  652.             if(PlayerPrefs.GetInt("VelestorDevice") == 1 && PlayerPrefs.GetInt("control") == 1)
  653.             {
  654.                 uBluetooth.Send(toSend);
  655.             }
  656. #endif
  657.        
  658.     }
  659.  
  660.     private static string getChecksum(string sentence)
  661.     {
  662.         int checksum = Convert.ToByte(sentence[sentence.IndexOf('$') + 1]);
  663.         for (int i = sentence.IndexOf('$') + 2; i < sentence.IndexOf('*'); i++)
  664.         {
  665.             checksum ^= Convert.ToByte(sentence[i]);
  666.         }
  667.         return checksum.ToString("X2");
  668.     }
  669.  
  670.     private void GetBigScreenshot()
  671.     {
  672.         try
  673.         {
  674.             ScreenshotCamera.transform.position = GetScreenshotPosition();
  675.             ScreenshotCamera.orthographicSize = GetOrthographicSize(true);
  676.             if (ScreenshotCamera.orthographicSize == 0)
  677.                 ScreenshotCamera.orthographicSize = 100;
  678.             RenderTexture rt = new RenderTexture(640, 720, 24);
  679.             ScreenshotCamera.targetTexture = rt;
  680.             ScreenshotCamera.Render();
  681.             //RenderNormalCamera();
  682.             ScreenshotCamera.targetTexture = rt;
  683.             Texture2D screenShot = new Texture2D(640, 720, TextureFormat.RGBA32, false);
  684.             RenderTexture.active = rt;
  685.             screenShot.ReadPixels(new Rect(0, 0, 640, 720), 0, 0);
  686.             ScreenshotCamera.targetTexture = null;
  687.             RenderTexture.active = null; // JC: added to avoid errors
  688.  
  689.             byte[] bytes = screenShot.EncodeToPNG();
  690.             string filename = Convert.ToBase64String(bytes);
  691.             SaveController.Instance.InsertBigScreenshot(SaveController.Instance.data.saveIndex, filename);
  692.             PromptWindow.Instance._async.allowSceneActivation = true;
  693.         }
  694.         catch (Exception ex)
  695.         {
  696.             PromptWindow.Instance._async.allowSceneActivation = true;
  697.         }
  698.     }
  699.  
  700.     private Vector3 GetScreenshotPosition()
  701.     {
  702.         return new Vector3((minX + maxX) / 2, 100, (minY + maxY) / 2);
  703.     }
  704.  
  705.     private float GetOrthographicSize(bool isBig = false)
  706.     {
  707.         ScreenshotCamera.transform.eulerAngles = new Vector3(ScreenshotCamera.transform.eulerAngles.x, 180, ScreenshotCamera.transform.eulerAngles.z);
  708.         float x = (maxX - minX) / 5f;
  709.         float y = (maxY - minY) / 5f;
  710.  
  711.         if (isBig)
  712.         {
  713.             x = x * 3;
  714.             y = y * 3;
  715.         }
  716.  
  717.         if (x < 0)
  718.             x = x * -1;
  719.         if (y < 0)
  720.             y = y * -1;
  721.  
  722.         x *= 1.5f;
  723.         y *= 1.5f;
  724.  
  725.         if (x > y)
  726.         {
  727.             if (isBig)
  728.                 ScreenshotCamera.transform.eulerAngles = new Vector3(ScreenshotCamera.transform.eulerAngles.x, -90, ScreenshotCamera.transform.eulerAngles.z);
  729.             return x;
  730.         }
  731.         else
  732.         {
  733.             if (!isBig)
  734.                 ScreenshotCamera.transform.eulerAngles = new Vector3(ScreenshotCamera.transform.eulerAngles.x, -90, ScreenshotCamera.transform.eulerAngles.z);
  735.             return y;
  736.         }
  737.     }
  738.  
  739.     bool firstPos = true;
  740.  
  741.  
  742.  
  743.     private List<Vector2> positionsForDelta = new List<Vector2>();
  744.     private List<float> speedForDelta = new List<float>();
  745.     private int tempPointIndex = 0;
  746.     public List<GameObject> selectedPoints = new List<GameObject>();
  747.     private bool SendLimit = false;
  748.     private string checkDate = "";
  749.     private int timeToDisconnect = 0;
  750.     private IEnumerator GetPositions()
  751.     {
  752.         while (true)
  753.         {
  754.  
  755. #if UNITY_EDITOR || !UNITY_WSA_10_0
  756.             if (gpsActivityJavaClass != null)
  757.             {
  758.                 string debug = gpsActivityJavaClass.CallStatic<string>("GetText");
  759.                 debugText.text = debug;
  760.                 string speedMessage = gpsActivityJavaClass.CallStatic<string>("getSpeed");
  761.                 string getConnected = gpsActivityJavaClass.CallStatic<string>("getConnected");
  762.                 if (getConnected != "true")
  763.                 {
  764.                     yield return null;
  765.                 }
  766.                 if (speedMessage != "Success")
  767.                 {
  768.                     loadingScreen.SetActive(false);
  769.                     speed = float.Parse(speedMessage);
  770.                     speedText.text = Math.Round(speed, 0).ToString();
  771.                     loadingScreen.SetActive(false);
  772.                     if (IsConnected == false && PlayerPrefs.GetString("deviceId").Length != 10)
  773.                     {
  774.                         gpsActivityJavaClass.CallStatic<string>("SendData", PlayerPrefs.GetString("deviceSpeed") + "\r\n");
  775.                     }
  776.  
  777.                     IsConnected = true;
  778.                 }
  779.                 else
  780.                 {
  781.                     SendLimit = false;
  782.                     IsConnected = false;
  783.                     loadingScreen.SetActive(true);
  784.                     //speedText.text = "Скорость не доступна. Соеденение";
  785.                     speedText.text = "0";
  786.                     sattelitesCountText.text = LanguageManager.Instance.GetTextValue("SattelitesLbl") + "-";
  787.                     //hdop2Text.text = "HDOP: " + "-";
  788.                     string mac = PlayerPrefs.GetString("mac");
  789.                     string pin = PlayerPrefs.GetString("pin");
  790.                     string deviceName = PlayerPrefs.GetString("device");
  791.                     string test = gpsActivityJavaClass.CallStatic<string>("SetAdress", mac, pin, deviceName);
  792.  
  793.                     //SceneManager.LoadScene(1);
  794.                     yield return null;
  795.                 }
  796.                 if (IsConnected)
  797.                 {
  798.                     AndroidJavaObject bjObject = gpsActivityJavaClass.CallStatic<AndroidJavaObject>("getSattelites");
  799.                     if (bjObject != null)
  800.                     {
  801.                         int SattelitesCount = bjObject.Get<int>("SattelitesCount");
  802.                         if (IsConnected)
  803.                             sattelitesCountText.text = LanguageManager.Instance.GetTextValue("SattelitesLbl") + SattelitesCount.ToString();
  804.                     }
  805.                 }
  806.             }
  807.             else
  808.             {
  809.                 AndroidJNI.AttachCurrentThread();
  810.                 gpsActivityJavaClass = new AndroidJavaClass("com.velestor.tractor.GPSTest");
  811.             }
  812. #else
  813.             try
  814.             {
  815.                 if (!isDemo)
  816.                 {
  817.                     float speedMessage = uBluetooth.GetSpeed();
  818.                     if (uBluetooth.isConnected)
  819.                     {
  820.                         loadingScreen.SetActive(false);
  821.                         speed = speedMessage;
  822.                         speedText.text = Math.Round(speed, 0).ToString();
  823.                         loadingScreen.SetActive(false);
  824.                         IsConnected = true;
  825.                     }
  826.                     else
  827.                     {
  828.                         SendLimit = false;
  829.                         IsConnected = false;
  830.                         loadingScreen.SetActive(true);
  831.                         //speedText.text = "Скорость не доступна. Соеденение";
  832.                         speedText.text = "0";
  833.                         sattelitesCountText.text = LanguageManager.Instance.GetTextValue("SattelitesLbl") + "-";
  834.                         hdop2Text.text = "HDOP: " + "-";
  835.                     }
  836.                     if (IsConnected)
  837.                     {
  838.  
  839.                         float SattelitesCount = uBluetooth.GetSattelites();
  840.                         if (IsConnected)
  841.                             sattelitesCountText.text = LanguageManager.Instance.GetTextValue("SattelitesLbl") + SattelitesCount.ToString();
  842.  
  843.                         string toSend = PlayerPrefs.GetString("deviceSpeed") + "\r\n";
  844.                         uBluetooth.Send(toSend);
  845.                     }
  846.                 }
  847.                 else
  848.                 {
  849.                     if (uBluetooth.isConnected)
  850.                     {
  851.                         if (toSendTime >= 50)
  852.                         {
  853.                             string toSend = PlayerPrefs.GetString("deviceSpeed") + "\r\n";
  854.                             uBluetooth.Send(toSend);
  855.                             toSendTime = 0;
  856.                         }
  857.                         GenerateSendData();
  858.                         toSendTime++;
  859.                     }
  860.                 }
  861.             }
  862.             catch (Exception ex)
  863.             {
  864.  
  865.             }
  866.  
  867. #endif
  868.  
  869. #if UNITY_EDITOR || !UNITY_WSA_10_0
  870.             yield return new WaitForSeconds(1);
  871. #else
  872.             yield return new WaitForSeconds(0.1f);
  873. #endif
  874.         }
  875.     }
  876.  
  877.     private int pointsCount = 0;
  878.     private int pointsCountt = 0;
  879.     private float time = 0;
  880.     private int toSendTime = 0;
  881.     private IEnumerator GetPositionsFromBluetooth()
  882.     {
  883.         while (true)
  884.         {
  885.             if (IsConnected)
  886.             {
  887. #if UNITY_EDITOR || !UNITY_WSA_10_0
  888.                 if (gpsActivityJavaClass != null)
  889.                 {
  890.                     AndroidJavaObject ajObject = gpsActivityJavaClass.CallStatic<AndroidJavaObject>("getLocation");
  891.                     if (ajObject != null)
  892.                     {
  893.                         double lat = ajObject.Get<double>("Latitude");
  894.                         double lon = ajObject.Get<double>("Longitude");
  895.                         double ac = ajObject.Get<float>("Quality");
  896.                         double hdop = ajObject.Get<float>("HDOP");
  897.                         hdop2Text.text = "HDOP: " + Math.Round(hdop, 1).ToString();
  898.                         altitude = float.Parse(gpsActivityJavaClass.CallStatic<string>("GetAltitude"));
  899.                         Vector2 newPos = new Vector2(KMLController.lonToX((float)lon) * 50, KMLController.latToZ((float)lat) * 60f);
  900.  
  901.                         if (lat != 0 && lon != 0)
  902.                         {
  903.                             if (!SendLimit)
  904.                             {
  905.                                 if (gpsActivityJavaClass != null && PlayerPrefs.GetString("deviceId").Length != 10)
  906.                                 {
  907.                                     gpsActivityJavaClass.CallStatic<string>("SendData", PlayerPrefs.GetString("deviceSpeed") + "\r\n");
  908.                                     SendLimit = true;
  909.                                 }
  910.                             }
  911.                             if (firstPosition == Vector2.zero)
  912.                             {
  913.                                 if (SaveController.Instance.data.startingPos != Vector2.zero)
  914.                                 {
  915.                                     firstPosition = SaveController.Instance.data.startingPos;
  916.                                 }
  917.                                 else
  918.                                 {
  919.                                     SaveController.Instance.data.startingPos = newPos;
  920.                                     firstPosition = newPos;
  921.                                     SaveController.Instance.InsertFristPosition(firstPosition);
  922.                                 }
  923.                             }
  924.  
  925.                             var point = Instantiate(NextPoint);
  926.                             point.gameObject.transform.SetParent(parent.transform, false);
  927.                             point.transform.localRotation = NextPoint.gameObject.transform.localRotation;
  928.                             point.transform.localPosition = new Vector3(firstPosition.x - newPos.x, NextPoint.gameObject.transform.localPosition.y, firstPosition.y - newPos.y);
  929.                             //Debug.Log("xpn: " + (firstPosition.x - newPos.x) + "  ynp: " + (firstPosition.y - newPos.y));
  930.  
  931.                             if (isContinue && !setPositionFromSave)
  932.                             {
  933.                                 transform.position = new Vector3(point.transform.position.x, transform.position.y, point.transform.position.z);
  934.                                 setPositionFromSave = true;
  935.                             }
  936.  
  937.                             if (speed > speedLimit)// && speed > 0.01f)
  938.                             {
  939.                                 Points.Add(point);
  940.                                 currentTime = 0;
  941.  
  942.                                 pointsCount++;
  943.  
  944.                                 if (pointsCount >= pointsDealey)
  945.                                 {
  946.                                     point.transform.position = CreateSector();
  947.  
  948.                                     if (selectedPoints.Count >= sectorsDealey)
  949.                                     {
  950.                                         bool movingState = isMoving;
  951.                                         if (!isMoving)
  952.                                         {
  953.                                             transform.LookAt(point.transform);
  954.                                         }
  955.  
  956.                                         GameObject prevSector = NextPoint;
  957.                                         GameObject newPoint = GetFinestPosition();
  958.                                         prevSector.GetComponent<MeshRenderer>().material = PassedPointMaterial;
  959.  
  960.                                         if (movedCount > 2 && CheckWorkType.Instance.typeId == 8)
  961.                                         {
  962.  
  963.                                             float widthM = (float)SaveController.Instance.data.widthM;
  964.                                             float widthSM = (float)SaveController.Instance.data.widthSM / 100;
  965.                                             float delt = (widthM + widthSM) / 2;
  966.  
  967.                                             double xM =
  968.                                                 KMLController.xToLon(
  969.                                                 (-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).x +
  970.                                                  firstPosition.x) / 50);
  971.                                             double yM =
  972.                                                 KMLController.zToLat(
  973.                                                 (-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).z +
  974.                                                  firstPosition.y) / 60);
  975.                                             gpxString += xM + "," + yM + "," + Math.Round(speed, 2) + "," + altitude + "," + currentDate +
  976.                                                          " \r\n";
  977.  
  978.                                         }
  979.  
  980.                                         if (MainRightPanel.Instance.Paint)
  981.                                         {
  982.                                             if (needToAddPosition)
  983.                                             {
  984.                                                 float delt = (SaveController.Instance.data.widthM + SaveController.Instance.data.widthSM / 100) / 2;
  985.                                                 double xR = KMLController.xToLon((-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).x + firstPosition.x) / 50);
  986.                                                 double yR = KMLController.zToLat((-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).z + firstPosition.y) / 60);
  987.                                                 double xL = KMLController.xToLon((-(arrowTransform.position + (-arrowTransform.up * (delt * 6.278353f))).x + firstPosition.x) / 50);
  988.                                                 double yL = KMLController.zToLat((-(arrowTransform.position + (-arrowTransform.up * (delt * 6.278353f))).z + firstPosition.y) / 60);
  989.                                                 if (CheckWorkType.Instance.typeId == 8)
  990.                                                 {
  991.                                                     if (!SquareController.Instance.newMode ||
  992.                                                         (SquareController.Instance.newMode &&
  993.                                                          SquareController.InSquare(
  994.                                                              SquareController.Instance.linePositions.ToArray(),
  995.                                                              transform.position)))
  996.                                                     {
  997.                                                         forGoogleString += lat + "," + lon + "|";
  998.                                                         forKMLLeft += xL + "," + yL + "," + altitude + " \r\n";
  999.                                                         kmlRightList.Add(xR + "," + yR + "," + altitude + " \r\n");
  1000.                                                         forKML += lat + "," + lon + "," + altitude + " \r\n";
  1001.                                                     }
  1002.                                                     double xM = KMLController.xToLon((-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).x + firstPosition.x) / 50);
  1003.                                                     double yM = KMLController.zToLat((-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).z + firstPosition.y) / 60);
  1004.                                                     //gpxString += xM + "," + yM + "," + Math.Round(speed, 2) + ","+altitude+","+currentDate+" \r\n";
  1005.                                                     minSpeed = SpeedWindow.Instance.CurrentMinSpeed;
  1006.                                                     maxSpeed = SpeedWindow.Instance.CurrentMaxSpeed;
  1007.                                                 }
  1008.                                                 else
  1009.                                                 {
  1010.                                                     if (!SquareController.Instance.newMode ||
  1011.                                                         (SquareController.Instance.newMode &&
  1012.                                                          SquareController.InSquare(
  1013.                                                              SquareController.Instance.linePositions.ToArray(),
  1014.                                                              transform.position)))
  1015.                                                     {
  1016.                                                         forGoogleString += lat + "," + lon + "|";
  1017.                                                         forKMLLeft += xL + "," + yL + ",0 \r\n";
  1018.                                                         kmlRightList.Add(xR + "," + yR + ",0 \r\n");
  1019.                                                         forKML += lat + "," + lon + ",0 \r\n";
  1020.                                                     }
  1021.                                                 }
  1022.                                                 PlayerPrefs.SetString("map" + SaveController.Instance.data.saveIndex, forGoogleString);
  1023.                                                 needToAddPosition = false;
  1024.                                             }
  1025.                                             else
  1026.                                             {
  1027.                                                 needToAddPosition = true;
  1028.                                             }
  1029.                                             speeds.Add(speed);
  1030.                                         }
  1031.                                         if (SquareController.Instance.isTracked)
  1032.                                         {
  1033.                                             if (needToAddSquare)
  1034.                                             {
  1035.                                                 if (CheckWorkType.Instance.typeId == 8)
  1036.                                                 {
  1037.                                                     kmlSquare += lon + "," + lat + "," + altitude + " \r\n";
  1038.                                                 }
  1039.                                                 else
  1040.                                                 {
  1041.                                                     kmlSquare += lon + "," + lat + ",0 \r\n";
  1042.                                                 }
  1043.                                                 if (string.IsNullOrEmpty(kmlStartSquare))
  1044.                                                 {
  1045.                                                     kmlStartSquare = kmlSquare;
  1046.                                                 }
  1047.                                                 needToAddSquare = false;
  1048.                                             }
  1049.                                             else
  1050.                                             {
  1051.                                                 needToAddSquare = true;
  1052.                                             }
  1053.                                         }
  1054.  
  1055.                                         if (newPoint != null)
  1056.                                         {
  1057.                                             bool needToRotate = false;
  1058.                                             NextPoint = newPoint;
  1059.                                             if (NextPoint.transform.position != prevSector.transform.position)
  1060.                                             {
  1061.                                                 prevSector.transform.LookAt(NextPoint.transform);
  1062.                                                 NextPoint.transform.rotation = prevSector.transform.rotation;
  1063.                                                 needToRotate = true;
  1064.                                             }
  1065.  
  1066.                                             int i = selectedPoints.IndexOf(NextPoint);
  1067.                                             for (int k = i; k >= 0; k--)
  1068.                                             {
  1069.                                                 selectedPoints.RemoveAt(k);
  1070.                                             }
  1071.  
  1072.                                             if (isMoving)
  1073.                                             {
  1074.                                                 if (trailer[0].transform.parent != null && ponitCount == 3)
  1075.                                                 {
  1076.  
  1077.  
  1078.                                                     //SetZOffset(normalOffset);
  1079.  
  1080.                                                     StartCoroutine(SmoothChangeJoint(normalOffset + 1, Gz * ((pointsDealey) * (sectorsDealey - selectedPoints.Count + 1)) * 2));// SetZOffset(normalOffset);
  1081.  
  1082.                                                     ponitCount = 0;
  1083.  
  1084.                                                     transform.LookAt(NextPoint.transform);
  1085.                                                     transform.LookAt(NextPoint.transform);
  1086.                                                     transform.LookAt(NextPoint.transform);
  1087.                                                     transform.LookAt(NextPoint.transform);
  1088.                                                     foreach (GameObject go in trailer)
  1089.                                                         go.transform.SetParent(null);
  1090.  
  1091.  
  1092.                                                     MainRightPanel.Instance.ContinueDraw();
  1093.                                                     isBack = false;
  1094.                                                 }
  1095.                                                 else if (trailer[0].transform.parent != null && ponitCount < 3)
  1096.                                                 {
  1097.                                                     //transform.LookAt(NextPoint.transform);
  1098.                                                     //transform.position = NextPoint.transform.position;
  1099.                                                     ponitCount++;
  1100.                                                 }
  1101.  
  1102.                                             }
  1103.  
  1104.                                             Vector3 heading = NextPoint.transform.position - transform.position;
  1105.                                             float dot = Vector3.Dot(heading, transform.forward);
  1106.                                             if (dot < -1 && trailer[0].transform.parent == null)
  1107.                                             {
  1108.                                                 /* Debug.Log("Dot: " + dot);
  1109.                                                  StopCoroutine("LookToEuler");
  1110.                                                  MainRightPanel.Instance.EndDraw();
  1111.  
  1112.                                                  foreach (GameObject go in trailer)
  1113.                                                  {
  1114.                                                      go.transform.SetParent(transform);
  1115.                                                      go.transform.localEulerAngles = Vector3.zero;
  1116.  
  1117.                                                  }
  1118.                                                  SetZOffset(0, 0);
  1119.                                                  transform.LookAt(NextPoint.transform);
  1120.                                                  */
  1121.                                             }
  1122.  
  1123.                                             isMoving = true;
  1124.  
  1125.                                             CheckForMinMax(new Vector2(NextPoint.transform.position.x, NextPoint.transform.position.z));
  1126.  
  1127.                                             if (!isBack)
  1128.                                             {
  1129.                                                 float angle = AngleSigned(transform.forward, NextPoint.transform.position - transform.position, transform.up);
  1130.                                                 if (movCor != null)
  1131.                                                 {
  1132.                                                     //StopCoroutine(movCor);
  1133.                                                 }
  1134.  
  1135.                                                 movCor = StartCoroutine(MoveToPosition(transform, prevSector.transform, NextPoint.transform.position, Gz * (pointsDealey * (sectorsDealey - selectedPoints.Count + 1))));
  1136.  
  1137.                                                 string androidDate = gpsActivityJavaClass.CallStatic<String>("GetDate");
  1138.                                                 if (string.IsNullOrEmpty(startingDate) && !string.IsNullOrEmpty(androidDate))
  1139.                                                 {
  1140.                                                     string[] dd = androidDate.Split(new[] { ' ' },
  1141.                                                         StringSplitOptions.RemoveEmptyEntries);
  1142.                                                     string d = string.Format("{0}/{1}/{2} {3}:{4}:{5}",
  1143.                                                         dd[0].Substring(0, 2), dd[0].Substring(2, 2),
  1144.                                                         dd[0].Substring(4, 2),
  1145.                                                         dd[1].Substring(0, 2), dd[1].Substring(2, 2),
  1146.                                                         dd[1].Substring(4, 2));
  1147.                                                     startingDate = d;
  1148.                                                     PlayerPrefs.SetString("date" + SaveController.Instance.data.saveIndex, startingDate);
  1149.                                                 }
  1150.                                                 else
  1151.                                                 {
  1152.                                                     string[] dd = androidDate.Split(new[] { ' ' },
  1153.                                                         StringSplitOptions.RemoveEmptyEntries);
  1154.                                                     string d = string.Format("{0}/{1}/{2} {3}:{4}:{5}",
  1155.                                                         dd[0].Substring(0, 2), dd[0].Substring(2, 2),
  1156.                                                         dd[0].Substring(4, 2),
  1157.                                                         dd[1].Substring(0, 2), dd[1].Substring(2, 2),
  1158.                                                         dd[1].Substring(4, 2));
  1159.                                                     currentDate = d;
  1160.                                                     if (currentDate.EndsWith("18"))
  1161.                                                     {
  1162.                                                         //PlayerPrefs.SetInt("NeedUpdate", 1);
  1163.                                                     }
  1164.                                                 }
  1165.  
  1166.                                                 if (firstPos)
  1167.                                                 {
  1168.  
  1169.                                                     SetZOffset(normalOffset);
  1170.                                                     foreach (GameObject go in trailer)
  1171.                                                         go.transform.SetParent(null);
  1172.  
  1173.                                                     SquareController.Instance.CheckAfterMove();
  1174.                                                     CurveController.Instance.CheckAfterMove();
  1175.                                                     ParalelsController.Instance.CheckAfterMove();
  1176.  
  1177.                                                 }
  1178.                                                 firstPos = false;
  1179.                                                 if (needToRotate)
  1180.                                                 {
  1181.                                                     if (rotCor != null)
  1182.                                                         StopCoroutine(rotCor);
  1183.  
  1184.                                                     if (dot > -4)
  1185.                                                     {
  1186.                                                         rotCor = StartCoroutine(LookToEuler(NextPoint.transform.rotation, Gz * ((pointsDealey) * (sectorsDealey - selectedPoints.Count + 1))));
  1187.                                                         if (trailer[0].transform.parent != null)
  1188.                                                         {
  1189.                                                             trailer[0].transform.SetParent(transform);
  1190.                                                             trailer[0].transform.localEulerAngles = Vector3.zero;
  1191.                                                         }
  1192.                                                     }
  1193.                                                     else
  1194.                                                     {
  1195.                                                         if (trailer[0].transform.parent == null)
  1196.                                                         {
  1197.                                                             if (rotCor != null)
  1198.                                                                 StopCoroutine(rotCor);
  1199.                                                             StopCoroutine(movCor);
  1200.                                                             MainRightPanel.Instance.EndDraw();
  1201.                                                             foreach (GameObject go in trailer)
  1202.                                                             {
  1203.  
  1204.                                                                 go.transform.SetParent(transform);
  1205.                                                                 go.transform.localEulerAngles = Vector3.zero;
  1206.                                                                 StopCoroutine("SmoothChangeJoint");
  1207.                                                                 //SetZOffset(0, 0);
  1208.                                                                 startingRotate = trackedPoint.rotation;
  1209.                                                                 StartCoroutine(SmoothChangeJoint(0, Gz * ((pointsDealey) * (sectorsDealey - selectedPoints.Count + 1))));// SetZOffset(normalOffset);//SetZOffset(0, 0);
  1210.                                                                 ponitCount = 0;
  1211.                                                                 //transform.LookAt(NextPoint.transform);
  1212.                                                             }
  1213.                                                             isBack = true;
  1214.                                                         }
  1215.                                                     }
  1216.                                                 }
  1217.                                             }
  1218.                                             else
  1219.                                             {
  1220.                                                 StopCoroutine(movCor);
  1221.                                             }
  1222.  
  1223.                                             /*else
  1224.                                             {
  1225.  
  1226.                                             }*/
  1227.  
  1228.                                             Points.Clear();
  1229.  
  1230.                                         }
  1231.  
  1232.  
  1233.                                     }
  1234.  
  1235.  
  1236.  
  1237.                                     pointsCount = 0;
  1238.                                 }
  1239.                                 else if (!isMoving && selectedPoints.Count == 1 && point.transform.position != transform.position)
  1240.                                 {
  1241.  
  1242.                                 }
  1243.                                 if (Points.Count >= 100)
  1244.                                 {
  1245.                                     Points.RemoveRange(0, 50);
  1246.                                 }
  1247.  
  1248.                             }
  1249.                             else
  1250.                             {
  1251.                                 StopCoroutine("MoveToPosition");
  1252.                             }
  1253.  
  1254.  
  1255.                         }
  1256.                         if (sendCount == 5)
  1257.                         {
  1258.                             GenerateSendData();
  1259.                             sendCount = 0;
  1260.                         }
  1261.                         sendCount++;
  1262.                     }
  1263.                 }
  1264. #else
  1265.  
  1266.                 PositionModel ajObject = uBluetooth.GetPosition();
  1267.                 altitude = uBluetooth.altitude;
  1268.                 if (ajObject != null)
  1269.                 {
  1270.                     double lat = ajObject.lat;
  1271.                     double lon = ajObject.lon;
  1272.                     double ac = 0;
  1273.                     double hdop = ajObject.hdop;
  1274.                     if (IsConnected)
  1275.                         hdop2Text.text = "HDOP: " + Math.Round(hdop, 1).ToString();
  1276.                     Vector2 newPos = new Vector2(KMLController.lonToX(lon) * 50, KMLController.latToZ(lat) * 60);
  1277.  
  1278.                     if (lat != 0 && lon != 0)
  1279.                     {
  1280.                         if (firstPosition == Vector2.zero)
  1281.                         {
  1282.                             if (SaveController.Instance.data.startingPos != Vector2.zero)
  1283.                             {
  1284.                                 firstPosition = SaveController.Instance.data.startingPos;
  1285.                             }
  1286.                             else
  1287.                             {
  1288.                                 SaveController.Instance.data.startingPos = newPos;
  1289.                                 firstPosition = newPos;
  1290.                                 SaveController.Instance.InsertFristPosition(firstPosition);
  1291.                             }
  1292.                         }
  1293.  
  1294.                         var point = Instantiate(NextPoint);
  1295.                         point.gameObject.transform.SetParent(parent.transform, false);
  1296.                         point.transform.localRotation = NextPoint.gameObject.transform.localRotation;
  1297.                         point.transform.localPosition = new Vector3(firstPosition.x - newPos.x, NextPoint.gameObject.transform.localPosition.y, firstPosition.y - newPos.y);
  1298.                         //Debug.Log("xpn: " + (firstPosition.x - newPos.x) + "  ynp: " + (firstPosition.y - newPos.y));
  1299.                         if (isContinue && !setPositionFromSave)
  1300.                         {
  1301.                             transform.position = new Vector3(point.transform.position.x,transform.position.y,point.transform.position.z);
  1302.                             setPositionFromSave = true;
  1303.                         }
  1304.  
  1305.                         if (speed > speedLimit)// && speed > 0.01f)
  1306.                         {
  1307.                             Points.Add(point);
  1308.                             currentTime = 0;
  1309.  
  1310.                             pointsCount++;
  1311.  
  1312.                             if (pointsCount >= pointsDealey)
  1313.                             {
  1314.                                 point.transform.position = CreateSector();
  1315.  
  1316.                                 if (selectedPoints.Count >= sectorsDealey)
  1317.                                 {
  1318.                                     bool movingState = isMoving;
  1319.                                     if (!isMoving)
  1320.                                     {
  1321.                                         transform.LookAt(point.transform);
  1322.                                     }
  1323.  
  1324.                                     GameObject prevSector = NextPoint;
  1325.                                     GameObject newPoint = GetFinestPosition();
  1326.                                     prevSector.GetComponent<MeshRenderer>().material = PassedPointMaterial;
  1327.                                      if (movedCount > 2 && CheckWorkType.Instance.typeId == 8)
  1328.                                             {
  1329.  
  1330.                                                 float widthM = (float) SaveController.Instance.data.widthM;
  1331.                                                 float widthSM = (float) SaveController.Instance.data.widthSM / 100;
  1332.                                                 float delt = (widthM + widthSM) / 2;
  1333.  
  1334.                                                 double xM =
  1335.                                                     KMLController.xToLon(
  1336.                                                     (-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).x +
  1337.                                                      firstPosition.x) / 50);
  1338.                                                 double yM =
  1339.                                                     KMLController.zToLat(
  1340.                                                     (-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).z +
  1341.                                                      firstPosition.y) / 60);
  1342.                                                 gpxString += xM + "," + yM + "," + Math.Round(speed, 2) + "," + altitude + "," + currentDate +
  1343.                                                              " \r\n";
  1344.  
  1345.                                             }
  1346.  
  1347.                                     if (MainRightPanel.Instance.Paint)
  1348.                                         {
  1349.                                             if (needToAddPosition)
  1350.                                             {
  1351.                                                 float delt = (SaveController.Instance.data.widthM + SaveController.Instance.data.widthSM / 100) / 2;
  1352.                                                 double xR = KMLController.xToLon((-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).x + firstPosition.x) / 50);
  1353.                                                 double yR = KMLController.zToLat((-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).z + firstPosition.y) / 60);
  1354.                                                 double xL = KMLController.xToLon((-(arrowTransform.position + (-arrowTransform.up * (delt * 6.278353f))).x + firstPosition.x) / 50);
  1355.                                                 double yL = KMLController.zToLat((-(arrowTransform.position + (-arrowTransform.up * (delt * 6.278353f))).z + firstPosition.y) / 60);
  1356.                                                 if (CheckWorkType.Instance.typeId == 8)
  1357.                                                 {
  1358.                 if (!SquareController.Instance.newMode ||
  1359.                                         (SquareController.Instance.newMode &&
  1360.                                          SquareController.InSquare(SquareController.Instance.linePositions.ToArray(),
  1361.                                              transform.position)))
  1362.                 {
  1363.                                                     forGoogleString += lat + "," + lon + "|";
  1364.                                                     forKMLLeft += xL + "," + yL + "," + altitude + " \r\n";
  1365.                                                     kmlRightList.Add(xR + "," + yR + "," + altitude + " \r\n");
  1366.                                                     forKML += lat + "," + lon + "," + altitude + " \r\n";
  1367.                 }
  1368.                                                     double xM = KMLController.xToLon((-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).x + firstPosition.x) / 50);
  1369.                                                     double yM = KMLController.zToLat((-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).z + firstPosition.y) / 60);
  1370.                                                     //gpxString += xM + "," + yM + "," + Math.Round(speed, 2) + ","+altitude+","+currentDate+" \r\n";
  1371.                                                     minSpeed = SpeedWindow.Instance.CurrentMinSpeed;
  1372.                                                     maxSpeed = SpeedWindow.Instance.CurrentMaxSpeed;
  1373.                                                    
  1374.                                                 }
  1375.                                                 else
  1376.                                                 {
  1377.                                                     forGoogleString += lat + "," + lon + "|";
  1378.                                                     forKMLLeft += xL + "," + yL + ",0 \r\n";
  1379.                                                     kmlRightList.Add(xR + "," + yR + ",0 \r\n");
  1380.                                                     forKML += lat + "," + lon + ",0 \r\n";
  1381.                                                 }
  1382.                                                 speeds.Add(speed);
  1383.                                                 PlayerPrefs.SetString("map" + SaveController.Instance.data.saveIndex, forGoogleString);
  1384.                                                 needToAddPosition = false;
  1385.                                             }
  1386.                                             else
  1387.                                             {
  1388.                                                 needToAddPosition = true;
  1389.                                             }
  1390.                                         }
  1391.                                         if (SquareController.Instance.isTracked)
  1392.                                         {
  1393.                                             if (needToAddSquare)
  1394.                                             {
  1395.                                                 if (CheckWorkType.Instance.typeId != 8)
  1396.                                                 {
  1397.                                                     kmlSquare += lat + "," + lon + ",0 \r\n";
  1398.                                                 }else
  1399.                                                 {
  1400.                                                     kmlSquare += lat + "," + lon + ","+altitude+" \r\n";
  1401.                                                 }
  1402.                                                 if (string.IsNullOrEmpty(kmlStartSquare))
  1403.                                                 {
  1404.                                                     kmlStartSquare = kmlSquare;
  1405.                                                 }
  1406.                                                 needToAddSquare = false;
  1407.                                             }
  1408.                                             else
  1409.                                             {
  1410.                                                 needToAddSquare = true;
  1411.                                             }
  1412.                                         }
  1413.                                     if (newPoint != null)
  1414.                                     {
  1415.                                         bool needToRotate = false;
  1416.                                         NextPoint = newPoint;
  1417.                                         if (NextPoint.transform.position != prevSector.transform.position)
  1418.                                         {
  1419.                                             prevSector.transform.LookAt(NextPoint.transform);
  1420.                                             NextPoint.transform.rotation = prevSector.transform.rotation;
  1421.                                             needToRotate = true;
  1422.                                         }
  1423.  
  1424.                                         int i = selectedPoints.IndexOf(NextPoint);
  1425.                                         for (int k = i; k >= 0; k--)
  1426.                                         {
  1427.                                             selectedPoints.RemoveAt(k);
  1428.                                         }
  1429.  
  1430.                                         if (isMoving)
  1431.                                         {
  1432.                                             if (trailer[0].transform.parent != null && ponitCount == 3)
  1433.                                             {
  1434.  
  1435.  
  1436.                                                 //SetZOffset(normalOffset);
  1437.  
  1438.                                                 StartCoroutine(SmoothChangeJoint(normalOffset + 1, Gz * ((pointsDealey) * (sectorsDealey - selectedPoints.Count + 1)) * 2));// SetZOffset(normalOffset);
  1439.  
  1440.                                                 ponitCount = 0;
  1441.  
  1442.                                                 transform.LookAt(NextPoint.transform);
  1443.                                                 transform.LookAt(NextPoint.transform);
  1444.                                                 transform.LookAt(NextPoint.transform);
  1445.                                                 transform.LookAt(NextPoint.transform);
  1446.                                                 foreach (GameObject go in trailer)
  1447.                                                     go.transform.SetParent(null);
  1448.  
  1449.  
  1450.                                                 MainRightPanel.Instance.ContinueDraw();
  1451.                                                 isBack = false;
  1452.                                             }
  1453.                                             else if (trailer[0].transform.parent != null && ponitCount < 3)
  1454.                                             {
  1455.                                                 //transform.LookAt(NextPoint.transform);
  1456.                                                 //transform.position = NextPoint.transform.position;
  1457.                                                 ponitCount++;
  1458.                                             }
  1459.  
  1460.                                         }
  1461.  
  1462.                                         Vector3 heading = NextPoint.transform.position - transform.position;
  1463.                                         float dot = Vector3.Dot(heading, transform.forward);
  1464.                                         if (dot < -1 && trailer[0].transform.parent == null)
  1465.                                         {
  1466.                                             /* Debug.Log("Dot: " + dot);
  1467.                                              StopCoroutine("LookToEuler");
  1468.                                              MainRightPanel.Instance.EndDraw();
  1469.  
  1470.                                              foreach (GameObject go in trailer)
  1471.                                              {
  1472.                                                  go.transform.SetParent(transform);
  1473.                                                  go.transform.localEulerAngles = Vector3.zero;
  1474.  
  1475.                                              }
  1476.                                              SetZOffset(0, 0);
  1477.                                              transform.LookAt(NextPoint.transform);
  1478.                                              */
  1479.                                         }
  1480.  
  1481.                                         isMoving = true;
  1482.  
  1483.                                         CheckForMinMax(new Vector2(NextPoint.transform.position.x, NextPoint.transform.position.z));
  1484.  
  1485.                                         if (!isBack)
  1486.                                         {
  1487.                                             float angle = AngleSigned(transform.forward, NextPoint.transform.position - transform.position, transform.up);
  1488.                                             if (movCor != null)
  1489.                                             {
  1490.                                                 //StopCoroutine(movCor);
  1491.                                             }
  1492.  
  1493.                                             movCor = StartCoroutine(MoveToPosition(transform, prevSector.transform, NextPoint.transform.position, Gz * (pointsDealey * (sectorsDealey - selectedPoints.Count + 1))));
  1494.  
  1495.                                            
  1496.                                             if (string.IsNullOrEmpty(uBluetooth.currentData) && !string.IsNullOrEmpty(uBluetooth.currentData))
  1497.                                             {
  1498.                                                 startingDate = uBluetooth.currentData;
  1499.                                                 PlayerPrefs.SetString("date" + SaveController.Instance.data.saveIndex, startingDate);
  1500.                                             }
  1501.                                             else
  1502.                                             {
  1503.                                                 currentDate = uBluetooth.currentData;
  1504.                                                 if (currentDate.EndsWith("18"))
  1505.                                                 {
  1506.                                                     //PlayerPrefs.SetInt("NeedUpdate", 1);
  1507.                                                 }
  1508.                                             }
  1509.  
  1510.                                             if (firstPos)
  1511.                                             {
  1512.  
  1513.                                                 SetZOffset(normalOffset);
  1514.                                                 foreach (GameObject go in trailer)
  1515.                                                     go.transform.SetParent(null);
  1516.  
  1517.                                                 SquareController.Instance.CheckAfterMove();
  1518.                                                 CurveController.Instance.CheckAfterMove();
  1519.                                                 ParalelsController.Instance.CheckAfterMove();
  1520.  
  1521.                                             }
  1522.                                             firstPos = false;
  1523.                                             if (needToRotate)
  1524.                                             {
  1525.                                                 if (rotCor != null)
  1526.                                                     StopCoroutine(rotCor);
  1527.  
  1528.                                                 if (dot > -4)
  1529.                                                 {
  1530.                                                     rotCor = StartCoroutine(LookToEuler(NextPoint.transform.rotation, Gz * ((pointsDealey) * (sectorsDealey - selectedPoints.Count + 1))));
  1531.                                                     if (trailer[0].transform.parent != null)
  1532.                                                     {
  1533.                                                         trailer[0].transform.SetParent(transform);
  1534.                                                         trailer[0].transform.localEulerAngles = Vector3.zero;
  1535.                                                     }
  1536.                                                 }
  1537.                                                 else
  1538.                                                 {
  1539.                                                     if (trailer[0].transform.parent == null)
  1540.                                                     {
  1541.                                                         if (rotCor != null)
  1542.                                                             StopCoroutine(rotCor);
  1543.                                                         StopCoroutine(movCor);
  1544.                                                         MainRightPanel.Instance.EndDraw();
  1545.                                                         foreach (GameObject go in trailer)
  1546.                                                         {
  1547.  
  1548.                                                             go.transform.SetParent(transform);
  1549.                                                             go.transform.localEulerAngles = Vector3.zero;
  1550.                                                             StopCoroutine("SmoothChangeJoint");
  1551.                                                             //SetZOffset(0, 0);
  1552.                                                             startingRotate = trackedPoint.rotation;
  1553.                                                             StartCoroutine(SmoothChangeJoint(0, Gz * ((pointsDealey) * (sectorsDealey - selectedPoints.Count + 1))));// SetZOffset(normalOffset);//SetZOffset(0, 0);
  1554.                                                             ponitCount = 0;
  1555.                                                             //transform.LookAt(NextPoint.transform);
  1556.                                                         }
  1557.                                                         isBack = true;
  1558.                                                     }
  1559.                                                 }
  1560.                                             }
  1561.                                         }
  1562.                                         else
  1563.                                         {
  1564.                                             StopCoroutine(movCor);
  1565.                                         }
  1566.  
  1567.                                         /*else
  1568.                                         {
  1569.  
  1570.                                         }*/
  1571.  
  1572.                                         Points.Clear();
  1573.  
  1574.                                     }
  1575.  
  1576.  
  1577.                                 }
  1578.  
  1579.  
  1580.  
  1581.                                 pointsCount = 0;
  1582.                             }
  1583.                             else if (!isMoving && selectedPoints.Count == 1 && point.transform.position != transform.position)
  1584.                             {
  1585.  
  1586.                             }
  1587.                             if (Points.Count >= 100)
  1588.                             {
  1589.                                 Points.RemoveRange(0, 50);
  1590.                             }
  1591.  
  1592.                         }
  1593.                         else
  1594.                         {
  1595.                             StopCoroutine("MoveToPosition");
  1596.                         }
  1597.  
  1598.  
  1599.                     }
  1600.                     if (sendCount == 1)
  1601.                     {
  1602.                         GenerateSendData();
  1603.                         sendCount = 0;
  1604.                     }
  1605.                     sendCount++;
  1606.                 }
  1607.  
  1608. #endif
  1609.             }
  1610.  
  1611.             yield return new WaitForSeconds(Gz);
  1612.         }
  1613.  
  1614.  
  1615.     }
  1616.  
  1617.     private int sendCount;
  1618.     private int ponitCount = 0;
  1619.     private Coroutine rotCor = null;
  1620.     private Coroutine movCor = null;
  1621.     public bool isBack = false;
  1622.     private float altitude = 0;
  1623.     private bool setPositionFromSave = false;
  1624.     private IEnumerator GetPositionsFromNMEA()
  1625.     {
  1626.         NMEAParser.Instance.StartGPS();
  1627.         while (true)
  1628.         {
  1629.  
  1630.             GPSData ajObject = NMEAParser.Instance.newData;
  1631.             if (ajObject != null)
  1632.             {
  1633.  
  1634.                 float xp = KMLController.lonToX(ajObject.position.x) * 50f;
  1635.                 float yp = KMLController.latToZ(ajObject.position.y) * 60f;
  1636.                 altitude = ajObject.altitude;
  1637.  
  1638.                 Vector2 newPos = new Vector2(xp, yp);
  1639.  
  1640.                 if (SaveController.Instance.data.debugData.pointsDealey == 0.1f)
  1641.                     newPos = new Vector2(newPos.x + UnityEngine.Random.Range(-1.03f, 1.03f), newPos.y + UnityEngine.Random.Range(-1.03f, 1.03f));
  1642.                 speed = ajObject.speed;
  1643.                 //if (ajObject.position.x != 0 && ajObject.position.y != 0)
  1644.                 //{
  1645.                 //    if (!CachedDynamicTileManager.Instance.Started)
  1646.                 //    {
  1647.                 //        CachedDynamicTileManager.Instance.Latitude = ajObject.position.y;
  1648.                 //        CachedDynamicTileManager.Instance.Longitude = ajObject.position.x;
  1649.                 //        CachedDynamicTileManager.Instance.StartParse();
  1650.                 //    }
  1651.                 //}
  1652.  
  1653.  
  1654.                 speedText.text = Math.Round(speed, 1).ToString();
  1655.  
  1656.  
  1657.  
  1658.                 if (ajObject.position.x != 0 && ajObject.position.y != 0 && speed > 1f)
  1659.                 {
  1660.                    
  1661.  
  1662.                     if (!SendLimit)
  1663.                     {
  1664. #if UNITY_EDITOR || !UNITY_WSA_10_0
  1665.                         if (gpsActivityJavaClass != null && PlayerPrefs.GetString("deviceId").Length != 10)
  1666.                         {
  1667.                             gpsActivityJavaClass.CallStatic<string>("SendData", PlayerPrefs.GetString("deviceSpeed") + "\r\n");
  1668.                             SendLimit = true;
  1669.                         }
  1670. #else
  1671. #endif
  1672.                     }
  1673.                     if (firstPosition == Vector2.zero)
  1674.                     {
  1675.                         if (SaveController.Instance.data.startingPos != Vector2.zero)
  1676.                         {
  1677.                             firstPosition = SaveController.Instance.data.startingPos;
  1678.                         }
  1679.                         else
  1680.                         {
  1681.                             SaveController.Instance.data.startingPos = newPos;
  1682.                             firstPosition = newPos;
  1683.                             SaveController.Instance.InsertFristPosition(firstPosition);
  1684.                         }
  1685.                     }
  1686.  
  1687.                     var point = Instantiate(NextPoint);
  1688.                     point.gameObject.transform.SetParent(parent.transform, false);
  1689.                     point.transform.localRotation = NextPoint.gameObject.transform.localRotation;
  1690.                     point.transform.localPosition = new Vector3(firstPosition.x - newPos.x, NextPoint.transform.position.y, firstPosition.y - newPos.y);
  1691.  
  1692.                     //Debug.Log("xpn: " + (firstPosition.x - newPos.x).ToString("F4") + "  ynp: " + (firstPosition.y - newPos.y).ToString("F4"));
  1693.  
  1694.                     if (speed > speedLimit)// && speed > 0.01f)
  1695.                     {
  1696.                         Points.Add(point);
  1697.                         currentTime = 0;
  1698.  
  1699.                         pointsCount++;
  1700.  
  1701.  
  1702.                         if (movedCount > 2 && CheckWorkType.Instance.typeId == 8)
  1703.                         {
  1704.  
  1705.                             float widthM = (float)SaveController.Instance.data.widthM;
  1706.                             float widthSM = (float)SaveController.Instance.data.widthSM / 100;
  1707.                             float delt = (widthM + widthSM) / 2;
  1708.  
  1709.                             double xM =
  1710.                                 KMLController.xToLon(
  1711.                                 (-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).x +
  1712.                                  firstPosition.x) / 50);
  1713.                             double yM =
  1714.                                 KMLController.zToLat(
  1715.                                 (-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).z +
  1716.                                  firstPosition.y) / 60);
  1717.                             gpxString += xM + "," + yM + "," + Math.Round(speed, 2) + "," + altitude + "," + currentDate +
  1718.                                          " \r\n";
  1719.  
  1720.                         }
  1721.  
  1722.                         if (MainRightPanel.Instance.Paint && movedCount > 2)
  1723.                         {
  1724.                             if (needToAddPosition)
  1725.                             {
  1726.                                 float widthM = (float)SaveController.Instance.data.widthM;
  1727.                                 float widthSM = (float)SaveController.Instance.data.widthSM / 100;
  1728.                                 float delt = (widthM + widthSM) / 2;
  1729.  
  1730.                                 double xR = KMLController.xToLon((-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).x + firstPosition.x) / 50);
  1731.                                 double yR = KMLController.zToLat((-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).z + firstPosition.y) / 60);
  1732.                                 double xL = KMLController.xToLon((-(arrowTransform.position + (-arrowTransform.up * (delt * 6.278353f))).x + firstPosition.x) / 50);
  1733.                                 double yL = KMLController.zToLat((-(arrowTransform.position + (-arrowTransform.up * (delt * 6.278353f))).z + firstPosition.y) / 60);
  1734.                                 LineDrawController rightCub = Bar.Instance.cubs[Bar.Instance.cubs.Count - 1].GetComponent<LineDrawController>();
  1735.                                 LineDrawController leftCub = Bar.Instance.cubs[0].GetComponent<LineDrawController>();
  1736.  
  1737.                                 if (CheckWorkType.Instance.typeId == 8)
  1738.                                 {
  1739.                                     if (!SquareController.Instance.newMode ||
  1740.                                         (SquareController.Instance.newMode &&
  1741.                                          SquareController.InSquare(SquareController.Instance.linePositions.ToArray(),
  1742.                                              transform.position)))
  1743.                                     {
  1744.                                         forKMLLeft += xL + "," + yL + "," + altitude + " \r\n";
  1745.                                         kmlRightList.Add(xR + "," + yR + "," + altitude + " \r\n");
  1746.                                     }
  1747.                                     double xM = KMLController.xToLon((-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).x + firstPosition.x) / 50);
  1748.                                     double yM = KMLController.zToLat((-(arrowTransform.position + arrowTransform.up * (delt * 6.278353f)).z + firstPosition.y) / 60);
  1749.                                     //gpxString += xM + "," + yM + "," + Math.Round(speed, 2) + "," + altitude + "," + currentDate + " \r\n";
  1750.                                     minSpeed = SpeedWindow.Instance.CurrentMinSpeed;
  1751.                                     maxSpeed = SpeedWindow.Instance.CurrentMaxSpeed;
  1752.                                    
  1753.                                 }
  1754.                                 else
  1755.                                 {
  1756.                                     if (!SquareController.Instance.newMode ||
  1757.                                         (SquareController.Instance.newMode &&
  1758.                                          SquareController.InSquare(SquareController.Instance.linePositions.ToArray(),
  1759.                                              transform.position)))
  1760.                                     {
  1761.                                         forKMLLeft += xL + "," + yL + ",0 \r\n";
  1762.                                         kmlRightList.Add(xR + "," + yR + ",0 \r\n");
  1763.                                     }
  1764.                                     altOffset++;
  1765.                                 }
  1766.                                 speeds.Add(speed);
  1767.                                 //PlayerPrefs.SetString("map" + SaveController.Instance.data.saveIndex, forGoogleString);
  1768.                                 needToAddPosition = false;
  1769.                             }
  1770.                             else
  1771.                             {
  1772.                                 needToAddPosition = true;
  1773.                             }
  1774.                         }
  1775.  
  1776.                        
  1777.                         if (pointsCount >= pointsDealey || speed >= 12)
  1778.                         {
  1779.                             point.transform.position = CreateSector();
  1780.  
  1781.                             if (selectedPoints.Count >= sectorsDealey)
  1782.                             {
  1783.                                 bool movingState = isMoving;
  1784.                                 if (!isMoving)
  1785.                                 {
  1786.                                     transform.LookAt(point.transform);
  1787.                                 }
  1788.  
  1789.                                 GameObject prevSector = NextPoint;
  1790.                                 GameObject newPoint = GetFinestPosition();
  1791.                                 prevSector.GetComponent<MeshRenderer>().material = PassedPointMaterial;
  1792.                                 /*if (MainRightPanel.Instance.Paint)
  1793.                                 {
  1794.                                     if (needToAddPosition)
  1795.                                     {
  1796.                                         float widthM = (float)SaveController.Instance.data.widthM;
  1797.                                         float widthSM = (float)SaveController.Instance.data.widthSM / 100;
  1798.                                         float delt = (widthM + widthSM) / 2;
  1799.                                         double xR = KMLController.xToLon((-(trailer[0].transform.position + trailer[0].transform.right * (delt * 6.278353f)).x + firstPosition.x) / 50);
  1800.                                         double yR = KMLController.zToLat((-(trailer[0].transform.position + trailer[0].transform.right * (delt * 6.278353f)).z + firstPosition.y) / 60);
  1801.                                         double xL = KMLController.xToLon((-(trailer[0].transform.position + (-trailer[0].transform.right * (delt * 6.278353f))).x + firstPosition.x) / 50);
  1802.                                         double yL = KMLController.zToLat((-(trailer[0].transform.position + (-trailer[0].transform.right * (delt * 6.278353f))).z + firstPosition.y) / 60);
  1803.                                         forGoogleString += ajObject.position.y + "," + ajObject.position.y + "|";
  1804.                                         forKMLLeft += xL + "," + yL + ",0 \r\n";
  1805.                                         kmlRightList.Add(xR + "," + yR + ",0 \r\n");
  1806.                                         forKML += ajObject.position.x + "," + ajObject.position.y + ",0 \r\n";
  1807.                                         PlayerPrefs.SetString("map" + SaveController.Instance.data.saveIndex, forGoogleString);
  1808.                                         needToAddPosition = false;
  1809.                                     }
  1810.                                     else
  1811.                                     {
  1812.                                         needToAddPosition = true;
  1813.                                     }
  1814.                                 }*/
  1815.                                 if (SquareController.Instance.isTracked)
  1816.                                 {
  1817.                                     if (needToAddSquare)
  1818.                                     {
  1819.                                         if (CheckWorkType.Instance.typeId != 8)
  1820.                                         {
  1821.  
  1822.                                             kmlSquare += ajObject.position.x + "," + ajObject.position.y + ",0 \r\n";
  1823.                                         }
  1824.                                         else
  1825.                                         {
  1826.                                             kmlSquare += ajObject.position.x + "," + ajObject.position.y + ","+altitude+" \r\n";
  1827.                                         }
  1828.                                         if (string.IsNullOrEmpty(kmlStartSquare))
  1829.                                         {
  1830.                                             kmlStartSquare = kmlSquare;
  1831.                                         }
  1832.                                         needToAddSquare = false;
  1833.                                     }
  1834.                                     else
  1835.                                     {
  1836.                                         needToAddSquare = true;
  1837.                                     }
  1838.                                 }
  1839.  
  1840.                                 if (newPoint != null)
  1841.                                 {
  1842.                                     bool needToRotate = false;
  1843.                                     NextPoint = newPoint;
  1844.                                     if (NextPoint.transform.position != prevSector.transform.position)
  1845.                                     {
  1846.                                         prevSector.transform.LookAt(NextPoint.transform);
  1847.                                         NextPoint.transform.rotation = prevSector.transform.rotation;
  1848.                                         needToRotate = true;
  1849.                                     }
  1850.  
  1851.                                     int i = selectedPoints.IndexOf(NextPoint);
  1852.                                     for (int k = i; k >= 0; k--)
  1853.                                     {
  1854.                                         selectedPoints.RemoveAt(k);
  1855.                                     }
  1856.  
  1857.                                     if (isMoving)
  1858.                                     {
  1859.                                         if (trailer[0].transform.parent != null && ponitCount == 3)
  1860.                                         {
  1861.  
  1862.  
  1863.                                             //SetZOffset(normalOffset);
  1864.  
  1865.                                             StartCoroutine(SmoothChangeJoint(normalOffset + 1, Gz * ((pointsDealey) * (sectorsDealey - selectedPoints.Count + 1)) * 2));// SetZOffset(normalOffset);
  1866.  
  1867.                                             ponitCount = 0;
  1868.  
  1869.                                             transform.LookAt(NextPoint.transform);
  1870.                                             transform.LookAt(NextPoint.transform);
  1871.                                             transform.LookAt(NextPoint.transform);
  1872.                                             transform.LookAt(NextPoint.transform);
  1873.                                             foreach (GameObject go in trailer)
  1874.                                                 go.transform.SetParent(null);
  1875.  
  1876.  
  1877.                                             MainRightPanel.Instance.ContinueDraw();
  1878.                                             isBack = false;
  1879.                                         }
  1880.                                         else if (trailer[0].transform.parent != null && ponitCount < 3)
  1881.                                         {
  1882.                                             //transform.LookAt(NextPoint.transform);
  1883.                                             //transform.position = NextPoint.transform.position;
  1884.                                             ponitCount++;
  1885.                                         }
  1886.  
  1887.                                     }
  1888.  
  1889.                                     Vector3 heading = NextPoint.transform.position - transform.position;
  1890.                                     float dot = Vector3.Dot(heading, transform.forward);
  1891.                                     if (dot < -1 && trailer[0].transform.parent == null)
  1892.                                     {
  1893.                                         /* Debug.Log("Dot: " + dot);
  1894.                                          StopCoroutine("LookToEuler");
  1895.                                          MainRightPanel.Instance.EndDraw();
  1896.  
  1897.                                          foreach (GameObject go in trailer)
  1898.                                          {
  1899.                                              go.transform.SetParent(transform);
  1900.                                              go.transform.localEulerAngles = Vector3.zero;
  1901.  
  1902.                                          }
  1903.                                          SetZOffset(0, 0);
  1904.                                          transform.LookAt(NextPoint.transform);
  1905.                                          */
  1906.                                     }
  1907.  
  1908.                                     isMoving = true;
  1909.  
  1910.                                     CheckForMinMax(new Vector2(NextPoint.transform.position.x, NextPoint.transform.position.z));
  1911.                                     if (!isBack)
  1912.                                     {
  1913.                                         float angle = AngleSigned(transform.forward, NextPoint.transform.position - transform.position, transform.up);
  1914.                                         if (movCor != null)
  1915.                                         {
  1916.                                             //StopCoroutine(movCor);
  1917.                                         }
  1918.  
  1919.                                         if (string.IsNullOrEmpty(startingDate))
  1920.                                         {
  1921.                                             startingDate = ajObject.data;
  1922.                                             PlayerPrefs.SetString("date" + SaveController.Instance.data.saveIndex, startingDate);
  1923.                                         }
  1924.                                         else
  1925.                                         {
  1926.                                             currentDate = ajObject.data;
  1927.                                             if (currentDate.EndsWith("18"))
  1928.                                             {
  1929.                                                 //PlayerPrefs.SetInt("NeedUpdate", 1);
  1930.                                             }
  1931.                                         }
  1932.  
  1933.  
  1934.                                         movCor = StartCoroutine(MoveToPosition(transform, prevSector.transform, NextPoint.transform.position, Gz * (pointsDealey * (sectorsDealey - selectedPoints.Count + 1))));
  1935.                                         if (movedCount <= 2)
  1936.                                         {
  1937.                                             movedCount++;
  1938.                                         }
  1939.  
  1940.                                         if (firstPos)
  1941.                                         {
  1942.  
  1943.                                             SetZOffset(normalOffset);
  1944.                                             foreach (GameObject go in trailer)
  1945.                                                 go.transform.SetParent(null);
  1946.                                             SquareController.Instance.CheckAfterMove();
  1947.                                             CurveController.Instance.CheckAfterMove();
  1948.                                             ParalelsController.Instance.CheckAfterMove();
  1949.                                         }
  1950.                                         firstPos = false;
  1951.                                         if (needToRotate)
  1952.                                         {
  1953.                                             if (rotCor != null)
  1954.                                                 StopCoroutine(rotCor);
  1955.  
  1956.                                             if (dot > -4)
  1957.                                             {
  1958.                                                 rotCor = StartCoroutine(LookToEuler(NextPoint.transform.rotation, Gz * ((pointsDealey) * (sectorsDealey - selectedPoints.Count + 1))));
  1959.                                                 if (trailer[0].transform.parent != null)
  1960.                                                 {
  1961.                                                     trailer[0].transform.SetParent(transform);
  1962.                                                     trailer[0].transform.localEulerAngles = Vector3.zero;
  1963.                                                 }
  1964.                                             }
  1965.                                             else
  1966.                                             {
  1967.                                                 if (trailer[0].transform.parent == null)
  1968.                                                 {
  1969.                                                     if (rotCor != null)
  1970.                                                         StopCoroutine(rotCor);
  1971.                                                     StopCoroutine(movCor);
  1972.                                                     MainRightPanel.Instance.EndDraw();
  1973.                                                     foreach (GameObject go in trailer)
  1974.                                                     {
  1975.  
  1976.                                                         go.transform.SetParent(transform);
  1977.                                                         go.transform.localEulerAngles = Vector3.zero;
  1978.                                                         StopCoroutine("SmoothChangeJoint");
  1979.                                                         //SetZOffset(0, 0);
  1980.                                                         startingRotate = trackedPoint.rotation;
  1981.                                                         StartCoroutine(SmoothChangeJoint(0, Gz * ((pointsDealey) * (sectorsDealey - selectedPoints.Count + 1))));// SetZOffset(normalOffset);//SetZOffset(0, 0);
  1982.                                                         ponitCount = 0;
  1983.                                                         //transform.LookAt(NextPoint.transform);
  1984.                                                     }
  1985.                                                     isBack = true;
  1986.                                                 }
  1987.                                             }
  1988.                                         }
  1989.                                     }
  1990.                                     else
  1991.                                     {
  1992.                                         StopCoroutine(movCor);
  1993.                                     }
  1994.  
  1995.                                     /*else
  1996.                                     {
  1997.                                        
  1998.                                     }*/
  1999.  
  2000.                                     Points.Clear();
  2001.  
  2002.                                 }
  2003.  
  2004.  
  2005.                             }
  2006.  
  2007.  
  2008.  
  2009.                             pointsCount = 0;
  2010.                         }
  2011.                         else if (!isMoving && selectedPoints.Count == 1 && point.transform.position != transform.position)
  2012.                         {
  2013.  
  2014.                         }
  2015.                         if (Points.Count >= 100)
  2016.                         {
  2017.                             Points.RemoveRange(0, 50);
  2018.                         }
  2019.  
  2020.                     }
  2021.                     else
  2022.                     {
  2023.                         StopCoroutine("MoveToPosition");
  2024.                     }
  2025.  
  2026.  
  2027.                 }
  2028.  
  2029.                 if (sendCount == 5)
  2030.                 {
  2031. #if UNITY_EDITOR || !UNITY_WSA_10_0
  2032.                     GenerateSendData();
  2033. #endif
  2034.                     sendCount = 0;
  2035.                 }
  2036.                 sendCount++;
  2037.             }
  2038.             yield return new WaitForSeconds(Gz);
  2039.         }
  2040.     }
  2041.  
  2042.     private int forRotation = 0;
  2043.  
  2044.  
  2045.     public float minX = Mathf.Infinity;
  2046.     public float minY = Mathf.Infinity;
  2047.     public float maxX = -Mathf.Infinity;
  2048.     public float maxY = -Mathf.Infinity;
  2049.     public Quaternion startingRotate;
  2050.  
  2051.  
  2052.     private void CheckForMinMax(Vector2 pos)
  2053.     {
  2054.         if (pos.x < minX)
  2055.         {
  2056.             minX = pos.x;
  2057.         }
  2058.         else if (pos.x > maxX)
  2059.         {
  2060.             maxX = pos.x;
  2061.         }
  2062.  
  2063.         if (pos.y < minY)
  2064.         {
  2065.             minY = pos.y;
  2066.         }
  2067.         else if (pos.y > maxY)
  2068.         {
  2069.             maxY = pos.y;
  2070.         }
  2071.  
  2072.         PlayerPrefs.SetFloat("minX" + SaveController.Instance.data.saveIndex, minX);
  2073.         PlayerPrefs.SetFloat("maxX" + SaveController.Instance.data.saveIndex, maxX);
  2074.         PlayerPrefs.SetFloat("minY" + SaveController.Instance.data.saveIndex, minY);
  2075.         PlayerPrefs.SetFloat("maxY" + SaveController.Instance.data.saveIndex, maxY);
  2076.     }
  2077.  
  2078.     private GameObject GetFinestPosition()
  2079.     {
  2080.         float minAngle = 999;
  2081.         int selectedIndex = 0;
  2082.         for (int i = 0; i < selectedPoints.Count; i++)
  2083.         {
  2084.             var angle = AngleSigned(transform.position, selectedPoints[i].transform.position - transform.position, Vector3.up);
  2085.             if (angle > 0 && angle < minAngle)
  2086.             {
  2087.                 minAngle = angle;
  2088.                 selectedIndex = i;
  2089.             }
  2090.             else if (angle < 0 && minAngle > 0)
  2091.             {
  2092.                 minAngle = angle;
  2093.                 selectedIndex = i;
  2094.             }
  2095.             else if (angle < 0 && minAngle < 0 && angle > minAngle)
  2096.             {
  2097.                 minAngle = angle;
  2098.                 selectedIndex = i;
  2099.             }
  2100.             else if (angle == 0)
  2101.             {
  2102.                 selectedIndex = i;
  2103.             }
  2104.         }
  2105.         if (selectedIndex < selectedPoints.Count)
  2106.             return selectedPoints[selectedIndex];
  2107.         else if (selectedIndex >= selectedPoints.Count && selectedPoints.Count > 0)
  2108.         {
  2109.             return selectedPoints[0];
  2110.         }
  2111.         else
  2112.         {
  2113.             return Points[Points.Count - 1];
  2114.         }
  2115.  
  2116.     }
  2117.  
  2118.     private Vector3 CreateSector()
  2119.     {
  2120.         try
  2121.         {
  2122.             Dictionary<Vector2, List<GameObject>> sectors = new Dictionary<Vector2, List<GameObject>>();
  2123.             float sm = (6.278353f / 100) * (smDealey * 2);
  2124.             for (int i = Points.Count - (int)(pointsDealey); i < Points.Count; i++)
  2125.             {
  2126.                 int x = (int)(Points[i].transform.position.x * sm);
  2127.                 int z = (int)(Points[i].transform.position.z * sm);
  2128.                 Vector2 tmp = new Vector2(x, z);
  2129.                 if (sectors.ContainsKey(tmp))
  2130.                 {
  2131.                     sectors[tmp].Add(Points[i].gameObject);
  2132.                 }
  2133.                 else
  2134.                 {
  2135.                     sectors.Add(tmp, new List<GameObject>());
  2136.                     sectors[tmp].Add(Points[i].gameObject);
  2137.                 }
  2138.  
  2139.             }
  2140.             int max = 0;
  2141.             Vector2 tmpKey = Vector2.zero;
  2142.             foreach (KeyValuePair<Vector2, List<GameObject>> pair in sectors)
  2143.             {
  2144.                 if (sectors[pair.Key].Count >= max)
  2145.                 {
  2146.                     if (selectedPoints.Count == 0)
  2147.                     {
  2148.                         max = sectors.Count;
  2149.                         tmpKey = pair.Key;
  2150.                     }
  2151.                     else
  2152.                     {
  2153.                         if (Vector3.Distance(sectors[pair.Key][0].transform.position, selectedPoints[0].transform.position) > 0)
  2154.                         {
  2155.                             max = sectors.Count;
  2156.                             tmpKey = pair.Key;
  2157.                         }
  2158.                     }
  2159.                 }
  2160.             }
  2161.             var sphere = Instantiate(Sphere);
  2162.             sphere.gameObject.transform.SetParent(parent.transform, false);
  2163.  
  2164.             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);
  2165.  
  2166.             sphere.transform.position = pos;
  2167.             sphere.GetComponent<MeshRenderer>().material = NextPointMaterial;
  2168.             selectedPoints.Add(sphere);
  2169.  
  2170.             return sectors[tmpKey][0].transform.position;
  2171.         }
  2172.         catch (Exception ex)
  2173.         {
  2174.             return Points[Points.Count - 1].transform.position;
  2175.         }
  2176.     }
  2177.  
  2178.     public IEnumerator LookToEuler(Quaternion euler, float timeToMove)
  2179.     {
  2180.         var currentPos = transform.rotation;
  2181.         var t = 0f;
  2182.  
  2183.         while (t < 1)
  2184.         {
  2185.             t += Time.deltaTime / (timeToMove * 2);
  2186.  
  2187.             transform.rotation = Quaternion.Lerp(currentPos, euler, t);
  2188.             yield return null;
  2189.         }
  2190.     }
  2191.  
  2192.     public void ChangeFilter()
  2193.     {
  2194.         enabledFilter = !enabledFilter;
  2195.     }
  2196.  
  2197.     public IEnumerator SmoothChangeJoint(float to, float timeToMove)
  2198.     {
  2199.         var currentPos = trailerJoint[0].connectedAnchor.z;
  2200.         var t = 0f;
  2201.         float step = to / timeToMove * Time.deltaTime;
  2202.         float baseZ = 0;
  2203.  
  2204.  
  2205.         bool isDisabled = true;
  2206.         while (t < 1)
  2207.         {
  2208.             //stepToMove = normalDist / 6.278353f * Time.deltaTime / timeToMove;
  2209.             t += Time.deltaTime / timeToMove;
  2210.             baseZ = Mathf.Lerp(currentPos, to, t);
  2211.  
  2212.             if (to == 0)
  2213.             {
  2214.                 if (startingRotate == transform.rotation && isDisabled)
  2215.                 {
  2216.                     MainRightPanel.Instance.ContinueDraw();
  2217.                     isDisabled = false;
  2218.                 }
  2219.                 else if (startingRotate != transform.rotation)
  2220.                 {
  2221.                     if (!isDisabled)
  2222.                     {
  2223.                         MainRightPanel.Instance.EndDraw();
  2224.                     }
  2225.                 }
  2226.             }
  2227.  
  2228.             trailerJoint[0].connectedAnchor = new Vector3(0, 0, baseZ);
  2229.             yield return null;
  2230.         }
  2231.  
  2232.         if (to == 0)
  2233.         {
  2234.             MainRightPanel.Instance.EndDraw();
  2235.         }
  2236.  
  2237.     }
  2238.  
  2239.     public float stepToMove = 0;
  2240.  
  2241.     public IEnumerator MoveToPosition(Transform transform, Transform prev, Vector3 position, float timeToMove)
  2242.     {
  2243.         var currentPos = transform.position;
  2244.         var t = 0f;
  2245.         //timeToMove += 0.1f;
  2246.         float baseDist = Vector3.Distance(prev.position, position);
  2247.         stepToMove = baseDist / 5.238071f * Time.deltaTime / timeToMove;
  2248.         moved = true;
  2249.  
  2250.         while (t < 1)
  2251.         {
  2252.             //stepToMove = normalDist / 6.278353f * Time.deltaTime / timeToMove;
  2253.             t += Time.deltaTime / timeToMove;
  2254.  
  2255.             if (isBack)
  2256.             {
  2257.                 t = 1;
  2258.                 break;
  2259.             }
  2260.             if (MainRightPanel.Instance != null && MainRightPanel.Instance.Paint)
  2261.             {
  2262.                 movedDistance += stepToMove;
  2263.                 SaveController.Instance.data.distance = startingDistance + movedDistance;
  2264.                 int k = -1;
  2265.                 for (int i = 0; i < filledAreas.Count; i++)
  2266.                 {
  2267.                     if (filledAreas[i].width == (float)(MetricsWindow.Instance.metrics + ((float)MetricsWindow.Instance.sm / 100)))
  2268.                     {
  2269.                         k = i;
  2270.                         break;
  2271.                     }
  2272.                 }
  2273.  
  2274.                 if (k == -1)
  2275.                 {
  2276.                     FilledArea area = new FilledArea();
  2277.                     area.width = (float)(MetricsWindow.Instance.metrics + ((float)MetricsWindow.Instance.sm / 100));
  2278.                     filledAreas.Add(area);
  2279.                     k = filledAreas.Count - 1;
  2280.                 }
  2281.  
  2282.                 filledAreas[k].distance += stepToMove * (float)((float)TogglesPanel.Instance.workingToggles / (float)TogglesPanel.Instance.toggleCount);
  2283.                 SaveController.Instance.data.filledDistance = filledAreas[k].distance;
  2284.  
  2285.                 foreach (var drawer in MainRightPanel.Instance.controllers)
  2286.                 {
  2287.                     if(!TogglesPanel.Instance.indexes.Contains(drawer.index) && drawer.InArea)
  2288.                         drawer.CheckSquare();
  2289.                 }
  2290.             }
  2291.             SetMovedText();
  2292.  
  2293.             if (MainRightPanel.Instance.Paint)
  2294.             {
  2295.                 PlayerPrefs.SetFloat("posX" + SaveController.Instance.data.saveIndex, transform.position.x);
  2296.                 PlayerPrefs.SetFloat("posZ" + SaveController.Instance.data.saveIndex, transform.position.z);
  2297.             }
  2298.  
  2299.  
  2300.             if (!isBack)
  2301.                 transform.position = Vector3.Lerp(currentPos, position + offsetPos, t);
  2302.             yield return null;
  2303.         }
  2304.         if (SaveController.Instance.data.debugFileName != "-" || IsOriginalDevice)
  2305.         {
  2306.             if (speed < 3)
  2307.             {
  2308.                 pointsDealey = 0.2f * 10;
  2309.                 sectorsDealey = 4;
  2310.  
  2311.             }
  2312.             else if (speed >= 3 && speed <= 8)
  2313.             {
  2314.                 pointsDealey = 0.5f * 10;
  2315.                 sectorsDealey = 1;
  2316.             }
  2317.             else if (speed >= 8 && speed <= 15)
  2318.             {
  2319.                 pointsDealey = 0.4f * 10;
  2320.                 sectorsDealey = 1;
  2321.             }
  2322.             else if (speed >= 15 && speed <= 25)
  2323.             {
  2324.                 pointsDealey = 0.3f * 10;
  2325.                 sectorsDealey = 1;
  2326.             }
  2327.             else if (speed >= 25 && speed <= 65)
  2328.             {
  2329.                 pointsDealey = 0.2f * 10;
  2330.                 sectorsDealey = 1;
  2331.             }
  2332.             else
  2333.             {
  2334.                 pointsDealey = 1;
  2335.                 sectorsDealey = 1;
  2336.             }
  2337.         }
  2338.         moved = false;
  2339.     }
  2340.  
  2341.     public void AddOverSquare(float square)
  2342.     {
  2343.         overSquare += square;
  2344.     }
  2345.  
  2346.     public IEnumerator SaveWork()
  2347.     {
  2348.         while (true)
  2349.         {
  2350.             yield return new WaitForSeconds(60);
  2351.             try
  2352.             {
  2353.                 SaveController.Instance.SaveData();
  2354.             }
  2355.             catch
  2356.             {
  2357.  
  2358.             }
  2359.         }
  2360.     }
  2361.  
  2362.     private void SetMovedText()
  2363.     {
  2364.         if (startingDistance + movedDistance < 1000)
  2365.         {
  2366.             movedDistanceText.text = Math.Round(startingDistance + movedDistance, 1).ToString();
  2367.             speedKMText.text = "м";
  2368.         }
  2369.         else
  2370.         {
  2371.             movedDistanceText.text = (Math.Round((startingDistance + movedDistance) / 1000, 2)).ToString();
  2372.             speedKMText.text = "км";
  2373.         }
  2374.  
  2375.         float dist = 0;
  2376.         foreach (FilledArea area in filledAreas)
  2377.         {
  2378.             float tempDist = area.distance * area.width;
  2379.             if (tempDist < 0)
  2380.             {
  2381.                 tempDist *= -1;
  2382.             }
  2383.             if(!float.IsNaN(tempDist))
  2384.                 dist += tempDist;
  2385.         }
  2386.         filledDistanceText.text = (Math.Round((dist) / 10000 + startingFillingDistance, 2)).ToString();
  2387.         SaveController.Instance.data.filledDistance = (dist) / 10000 + startingFillingDistance;
  2388.         if (filledDistanceText.text == "NaN")
  2389.         {
  2390.             filledDistanceText.text = "0";
  2391.             SaveController.Instance.data.filledDistance = 0;
  2392.         }
  2393.  
  2394.  
  2395.     }
  2396.  
  2397.     private List<float> _distances = new List<float>();
  2398.     private GameObject[] LoadCoordinatesByName(string fileName, int distance)
  2399.     {
  2400.         var coords = KMLController.LoadXML(fileName);
  2401.         var pairs = KMLController.GetPairsFromLoadedKML(coords);
  2402.         if (_zeroPoint == Vector3.zero)
  2403.             _zeroPoint = coords[0];
  2404.         var newPoints = new GameObject[pairs.Count * 2];
  2405.         var parent = new GameObject(fileName);
  2406.         parent.gameObject.transform.SetParent(NextPoint.gameObject.transform.parent, false);
  2407.         for (int i = 0; i < pairs.Count; i++)
  2408.         {
  2409.             var item = pairs[i];
  2410.             var point = Instantiate(NextPoint);
  2411.             point.gameObject.transform.SetParent(parent.transform, false);
  2412.             point.transform.localRotation = NextPoint.gameObject.transform.localRotation;
  2413.             point.transform.localPosition = new Vector3(_zeroPoint.x - item.First.x, NextPoint.gameObject.transform.localPosition.y, _zeroPoint.z - item.First.z);
  2414.             //point.gameObject.SetActive(false);
  2415.             newPoints[i * 2] = point;
  2416.  
  2417.             point = Instantiate(NextPoint);
  2418.             point.gameObject.transform.SetParent(parent.transform, false);
  2419.             point.transform.localRotation = NextPoint.gameObject.transform.localRotation;
  2420.             point.transform.localPosition = new Vector3(_zeroPoint.x - item.Second.x, NextPoint.gameObject.transform.localPosition.y, _zeroPoint.z - item.Second.z);
  2421.             //point.gameObject.SetActive(false);
  2422.             newPoints[i * 2 + 1] = point;
  2423.  
  2424.             var dis = Vector3.Distance(pairs[i].First, pairs[i].Second) / distance;
  2425.             _distances.Add(dis);
  2426.             //Debug.LogError(dis);
  2427.         }
  2428.  
  2429.         NextPoint = newPoints[0];
  2430.  
  2431.         return newPoints;
  2432.     }
  2433.  
  2434.     private GameObject SkippedPoint = null;
  2435.  
  2436.     IEnumerator StartEmitor()
  2437.     {
  2438.         yield return new WaitForSeconds(0.1f);
  2439.         Particle.Play();
  2440.     }
  2441.  
  2442.     private float GetAngle()
  2443.     {
  2444.         var turnDir = (NextPoint.transform.position - transform.position);
  2445.         var rotationAngle = 0f;
  2446.         if (turnDir != Vector3.zero)
  2447.             rotationAngle = AngleAroundAxis(transform.forward, turnDir, Vector3.up);
  2448.         return rotationAngle;
  2449.     }
  2450.  
  2451.     private bool isPrevDirectionForvard = true;
  2452.     float prevAngle = 0f;
  2453.     public float speed = 0;
  2454.     private Vector3 lastPos = Vector3.zero;
  2455.  
  2456.     private float lastRotY = 0;
  2457.     private bool lastWorkState = false;
  2458.     private bool minSpeedAir = true;
  2459.     public void FixedUpdate()
  2460.     {
  2461.         if (CheckWorkType.Instance.typeId == 8 && SquareController.Instance.newMode && SquareController.InSquare(SquareController.Instance.linePositions.ToArray(),transform.position))
  2462.         {
  2463.             if (speed > SpeedWindow.Instance.CurrentMinSpeed && speed < SpeedWindow.Instance.CurrentMaxSpeed &&
  2464.                 !MainRightPanel.Instance.Paint)
  2465.             {
  2466.                 MainRightPanel.Instance.UI_OnTurnPaint(true);
  2467.             }else if ((speed < SpeedWindow.Instance.CurrentMinSpeed || speed > SpeedWindow.Instance.CurrentMaxSpeed) &&
  2468.                       MainRightPanel.Instance.Paint)
  2469.             {
  2470.                 MainRightPanel.Instance.UI_OnTurnPaint(false);
  2471.             }
  2472.         }else if (CheckWorkType.Instance.typeId == 8 && !SquareController.Instance.newMode)
  2473.         {
  2474.             if ((TractorController.Instance.speed < SpeedWindow.Instance.CurrentMinSpeed ||
  2475.                      TractorController.Instance.speed > SpeedWindow.Instance.CurrentMaxSpeed))
  2476.             {
  2477.                 if (!minSpeedAir)
  2478.                 {
  2479.                     MainRightPanel.Instance.UI_OnTurnPaint(false);
  2480.                     MainRightPanel.Instance.UI_OnTurnPaint(true);
  2481.                     minSpeedAir = true;
  2482.                 }
  2483.             }
  2484.             else if ((TractorController.Instance.speed > SpeedWindow.Instance.CurrentMinSpeed &&
  2485.                       TractorController.Instance.speed < SpeedWindow.Instance.CurrentMaxSpeed))
  2486.             {
  2487.                 if (minSpeedAir)
  2488.                 {
  2489.                     MainRightPanel.Instance.UI_OnTurnPaint(false);
  2490.                     MainRightPanel.Instance.UI_OnTurnPaint(true);
  2491.                     minSpeedAir = false;
  2492.                 }
  2493.             }
  2494.         }
  2495.  
  2496.             if (SquareController.Instance.newMode)
  2497.         {
  2498.             bool newWorkState = SquareController.InSquare(SquareController.Instance.linePositions.ToArray(),
  2499.                 trackedPoint.position);
  2500.             if (lastWorkState != newWorkState)
  2501.             {
  2502.                 MainRightPanel.Instance.UI_OnTurnPaint(false);
  2503.                 MainRightPanel.Instance.UI_OnTurnPaint(true);
  2504.             }
  2505.             lastWorkState = newWorkState;
  2506.         }
  2507.  
  2508.  
  2509.         /*Vector3 targetPostition = new Vector3(NextPoint.transform.position.x,
  2510.                                         Arrow.transform.transform.position.y,
  2511.                                         NextPoint.transform.position.z);
  2512.  
  2513.         Arrow.transform.LookAt(targetPostition);
  2514.         */
  2515.         var RotateFrontWheelTransform = RotateFrontWheels[0].transform;
  2516.         // var angle = trailer.transform.eulerAngles.y - transform.eulerAngles.y;// AngleSigned(trackedPoint.forward, transform.position - trackedPoint.position + trackedPoint.forward, trackedPoint.up);
  2517.         // trackedPoint.RotateAround(trackedPoint.position, Vector3.up, trackedPoint.position.y + angle);
  2518.  
  2519.         for (int i = 0; i < 2; i++)
  2520.         {
  2521.             // RotateFrontWheels[i].transform.RotateAround(FrontWheels[i].transform.position, Vector3.up, FrontWheels[i].transform.position.y + angle);
  2522.             //RotateFrontWheels[i].transform.localEulerAngles = new Vector3(0, 0, trackedPoint.localEulerAngles.y);
  2523.             if (CheckWorkType.Instance.typeId != 5)
  2524.             {
  2525.                 RotateFrontWheels[i].transform.eulerAngles = new Vector3(0, transform.eulerAngles.y - 180, 0);
  2526.                     // new Vector3(0,0, -angle);
  2527.             }
  2528.             //RotateFrontWheels[i].transform.LookAt(transform);
  2529.         }
  2530.         if (CheckWorkType.Instance.typeId != 5)
  2531.         {
  2532.             if (RotateFrontWheels[0].transform.localEulerAngles.x < 45)
  2533.             {
  2534.                 RotateFrontWheels[0].transform.localEulerAngles = new Vector3(45, 0, 0);
  2535.             }
  2536.             else if (RotateFrontWheels[0].transform.localEulerAngles.x > 135)
  2537.             {
  2538.                 RotateFrontWheels[0].transform.localEulerAngles = new Vector3(135, 0, 0);
  2539.             }
  2540.  
  2541.             if (RotateFrontWheels[1].transform.localEulerAngles.x < 45)
  2542.             {
  2543.                 RotateFrontWheels[1].transform.localEulerAngles = new Vector3(45, 0, 0);
  2544.             }
  2545.             else if (RotateFrontWheels[1].transform.localEulerAngles.x > 135)
  2546.             {
  2547.                 RotateFrontWheels[1].transform.localEulerAngles = new Vector3(135, 0, 0);
  2548.             }
  2549.         }
  2550.         // MoveToNextPoint();
  2551.  
  2552.         if (lastPos != transform.position)
  2553.         {
  2554.             float dist = Vector3.Distance(lastPos, transform.position);
  2555.             if (CheckWorkType.Instance.typeId != 5)
  2556.             {
  2557.                 foreach (var wheel in FrontWheels)
  2558.                     wheel.transform.Rotate(new Vector3(1, 0, 0), -(dist * 5));
  2559.                 foreach (var wheel in RearWheels)
  2560.                     wheel.transform.Rotate(new Vector3(1, 0, 0), -(dist * 4));
  2561.             }
  2562.             else
  2563.             {
  2564.                 foreach (var wheel in FrontWheels)
  2565.                     wheel.transform.Rotate(new Vector3(1, 0, 0), (dist * 5));
  2566.                 foreach (var wheel in RearWheels)
  2567.                     wheel.transform.Rotate(new Vector3(1, 0, 0), (dist * 4));
  2568.             }
  2569.  
  2570.             Move = true;
  2571.            
  2572.             //Vector3 vectorForOffset = (transform.position -lastPos).normalized;
  2573.             //GrounMaterial.mainTextureOffset = new Vector2(GrounMaterial.mainTextureOffset.x + vectorForOffset.x * Time.deltaTime / 3, GrounMaterial.mainTextureOffset.y + vectorForOffset.y * Time.deltaTime / 3);
  2574.             lastPos = transform.position;
  2575.  
  2576.             if (CheckWorkType.Instance.typeId == 7 && SquareController.Instance.isTracked)
  2577.             {
  2578.                 movedDistance += dist / 6.278354f;
  2579.                 if (startingDistance + movedDistance < 1000)
  2580.                 {
  2581.                     movedDistanceText.text = Math.Round(startingDistance + movedDistance, 1).ToString();
  2582.                     speedKMText.text = "м";
  2583.                 }
  2584.                 else
  2585.                 {
  2586.                     movedDistanceText.text = (Math.Round((startingDistance + movedDistance) / 1000, 2)).ToString();
  2587.                     speedKMText.text = "км";
  2588.                 }
  2589.             }
  2590.         }
  2591.         else
  2592.         {
  2593.             Move = false;
  2594.         }
  2595.        
  2596.     }
  2597.  
  2598.     private bool airOnGround = true;
  2599.  
  2600.     public bool isRotation = false;
  2601.  
  2602.     private IEnumerator TrackAirRotation()
  2603.     {
  2604.         while (true)
  2605.         {
  2606.             if (altitude < 1000)
  2607.             {
  2608.                 altitudeText.text = Math.Round(altitude, 1).ToString();
  2609.                 altitudeAdditionalText.text = "м";
  2610.             }
  2611.             else
  2612.             {
  2613.                 altitudeText.text = Math.Round(altitude / 1000, 1).ToString();
  2614.                 altitudeAdditionalText.text = "км";
  2615.             }
  2616.  
  2617.             if (isMoving && !isBack)
  2618.             {
  2619.  
  2620.                 float angle = AngleInDeg();
  2621.  
  2622.                
  2623.  
  2624.                 float x = transform.localEulerAngles.y - MainTransform.localEulerAngles.y;
  2625.                 if (x > 45 && x <= 180)
  2626.                 {
  2627.                     x = 180 - x;
  2628.                 }
  2629.                 else if (x > 180 && x <= 360)
  2630.                 {
  2631.                     x = x - 360;
  2632.                 }
  2633.  
  2634.                 float newAngle = Mathf.LerpAngle(x, angle, 0.01f);
  2635.                 newAngle = Mathf.LerpAngle(x, newAngle, 0.001f);
  2636.                 Vector3 airVector = new Vector3(-newAngle, airship.localEulerAngles.y, airship.localEulerAngles.z);
  2637.                 airVector = GetNormalVector(airVector);
  2638.                 Vector3 lastRotation = airship.localEulerAngles;
  2639.                 float timeCourotine = 0;
  2640.                 float to = airVector.x;
  2641.                 Vector3 newVector = airship.localEulerAngles;
  2642.                 if (!airOnGround)
  2643.                 {
  2644.                     isRotation = to >= 35 || to <= -35;
  2645.                     while (timeCourotine < 1)
  2646.                     {
  2647.                         newVector.x = Mathf.LerpAngle(lastRotation.x, to, timeCourotine);
  2648.                         airship.localEulerAngles = newVector;
  2649.                         //airship.localEulerAngles = Vector3.LerpUnclamped(lastRotation,airVector, timeCourotine);
  2650.                         timeCourotine += Time.deltaTime / 2;
  2651.                         yield return new WaitForSeconds(Time.deltaTime / 2);
  2652.                     }
  2653.                 }
  2654.                 else
  2655.                 {
  2656.                     while (timeCourotine < 1)
  2657.                     {
  2658.                         newVector.x = Mathf.LerpAngle(lastRotation.x, 0, timeCourotine);
  2659.                         airship.localEulerAngles = newVector;
  2660.                         //airship.localEulerAngles = Vector3.LerpUnclamped(lastRotation,airVector, timeCourotine);
  2661.                         timeCourotine += Time.deltaTime / 2;
  2662.                         yield return new WaitForSeconds(Time.deltaTime / 2);
  2663.                     }
  2664.                 }
  2665.                 if (speed > SpeedWindow.Instance.LandingSpeed && airOnGround)
  2666.                 {
  2667.                     float fromY = -10;
  2668.                     float toY = 31;
  2669.                     float timeToUp = 0;
  2670.                     Vector3 airPosition = airship.localPosition;
  2671.                     while (timeToUp < 1)
  2672.                     {
  2673.                         airPosition.y = Mathf.Lerp(fromY, toY, timeToUp);
  2674.                         airship.localPosition = airPosition;
  2675.                         timeToUp += Time.deltaTime / 4;
  2676.                         yield return new WaitForSeconds(Time.deltaTime / 2);
  2677.                     }
  2678.                     airOnGround = false;
  2679.                 }
  2680.                 else if (speed < SpeedWindow.Instance.LandingSpeed && !airOnGround)
  2681.                 {
  2682.                     float fromY = 31;
  2683.                     float toY = -10;
  2684.                     float timeToUp = 0;
  2685.                     Vector3 airPosition = airship.localPosition;
  2686.                     airOnGround = true;
  2687.                     while (timeToUp < 1)
  2688.                     {
  2689.                         airPosition.y = Mathf.Lerp(fromY, toY, timeToUp);
  2690.                         airship.localPosition = airPosition;
  2691.                         timeToUp += Time.deltaTime / 4;
  2692.                         yield return new WaitForSeconds(Time.deltaTime / 2);
  2693.                     }
  2694.                    
  2695.                 }
  2696.  
  2697.  
  2698.             }
  2699.             yield return new WaitForSeconds(Time.deltaTime);
  2700.         }
  2701.     }
  2702.  
  2703.     private Vector3 GetNormalVector(Vector3 airVector)
  2704.     {
  2705.         if (airVector.x > 45 && airVector.x <= 180)
  2706.         {
  2707.             airVector.x = 180 - airVector.x;
  2708.         }
  2709.         else if (airVector.x > 180 && airVector.x <= 360)
  2710.         {
  2711.             airVector.x = airVector.x - 360;
  2712.         }
  2713.  
  2714.         if (airVector.x < -45)
  2715.         {
  2716.             airVector.x = -45;
  2717.         }
  2718.         else if (airVector.x > 45)
  2719.         {
  2720.             airVector.x = 45;
  2721.         }
  2722.  
  2723.         if (airVector.y > 45 && airVector.y <= 180)
  2724.         {
  2725.             airVector.y = 180 - airVector.y;
  2726.         }
  2727.         else if (airVector.y > 180 && airVector.y <= 360)
  2728.         {
  2729.             airVector.y = airVector.y - 360;
  2730.         }
  2731.  
  2732.         if (airVector.y < -45)
  2733.         {
  2734.             airVector.y = -45;
  2735.         }
  2736.         else if (airVector.y > 45)
  2737.         {
  2738.             airVector.y = 45;
  2739.         }
  2740.  
  2741.  
  2742.         return airVector;
  2743.     }
  2744.  
  2745.     private float GetAngleBetweenAirShip()
  2746.     {
  2747.         Vector3 dir = MainTransform.position - transform.position;
  2748.         dir = MainTransform.InverseTransformDirection(dir);
  2749.         return Mathf.Atan2(dir.y, dir.x) * Mathf.Rad2Deg;
  2750.     }
  2751.  
  2752.     public float AngleInDegForCombine()
  2753.     {
  2754.         return AngleInRad(MainTransform.position, transform.position + transform.forward) * 180 / Mathf.PI;
  2755.     }
  2756.  
  2757.     public float AngleInRad(Vector3 vec1, Vector3 vec2)
  2758.     {
  2759.         return Mathf.Atan2(vec2.y - vec1.y, vec2.x - vec1.x);
  2760.     }
  2761.  
  2762.     //This returns the angle in degrees
  2763.     public float AngleInDeg()
  2764.     {
  2765.         return AngleInRad(MainTransform.position, transform.position) * 180 / Mathf.PI;
  2766.     }
  2767.  
  2768.     bool Move = false;
  2769.  
  2770.     float currentTime = 0;
  2771.  
  2772.  
  2773.  
  2774.     private float CalculateDistance()
  2775.     {
  2776.         float angle = Mathf.DeltaAngle(Mathf.Atan2(transform.position.x, transform.position.z) * Mathf.Rad2Deg,
  2777.                                  Mathf.Atan2(NextPoint.transform.position.x, NextPoint.transform.position.z) * Mathf.Rad2Deg);
  2778.         return angle;
  2779.     }
  2780.  
  2781.     public static float AngleAroundAxis(Vector3 dirA, Vector3 dirB, Vector3 axis)
  2782.     {
  2783.         // Project A and B onto the plane orthogonal target axis
  2784.         dirA = dirA - Vector3.Project(dirA, axis);
  2785.         dirB = dirB - Vector3.Project(dirB, axis);
  2786.  
  2787.         // Find (positive) angle between A and B
  2788.         float angle = Vector3.Angle(dirA, dirB);
  2789.  
  2790.         // Return angle multiplied with 1 or -1
  2791.         return angle * (Vector3.Dot(axis, Vector3.Cross(dirA, dirB)) < 0 ? -1 : 1);
  2792.     }
  2793.  
  2794.     public static float AngleSigned(Vector3 v1, Vector3 v2, Vector3 n)
  2795.     {
  2796.         return Mathf.Atan2(
  2797.             Vector3.Dot(n, Vector3.Cross(v1, v2)),
  2798.             Vector3.Dot(v1, v2)) * Mathf.Rad2Deg;
  2799.     }
  2800.  
  2801.     public void ChangeLight()
  2802.     {
  2803.         if (PlayerPrefs.GetInt("VelestorDevice") == 1)
  2804.         {
  2805.             light.SetActive(!light.activeSelf);
  2806.             if (CheckWorkType.Instance.typeId != 8)
  2807.             {
  2808.                 carLightTexture.SetActive(!light.activeSelf);
  2809.             }
  2810.             lights.SetActive(!light.activeSelf);
  2811.             DayNightSwitcher.Instance.SetColors(!carLightTexture.activeSelf);
  2812.         }
  2813.         else
  2814.         {
  2815.             MainGUI.Instance.StartShowCantOpen();
  2816.         }
  2817.     }
  2818.  
  2819.     public void AddParallelPoint()
  2820.     {
  2821.         ParalelsController.Instance.SetPosition(transform);
  2822.     }
  2823.  
  2824.     private void OnTriggerEnter(Collider col)
  2825.     {
  2826.         if (col.tag == "Lines")
  2827.         {
  2828.             ParalelsController.Instance.ChangeLines(col.gameObject);
  2829.         }
  2830.         else if (col.tag == "Curves")
  2831.         {
  2832.             if (col.gameObject.transform.parent != null)
  2833.             {
  2834.                 CurveController.Instance.ResetCurves(col.gameObject.transform.parent.gameObject);
  2835.                 CurveController.Instance.SetTrackedPoint(col.gameObject);
  2836.             }
  2837.         }else if (col.tag == "Areas")
  2838.         {
  2839.             //lastArea = col;
  2840.         }
  2841.     }
  2842.  
  2843.     public void ChangeBTMode()
  2844.     {
  2845.         if (gpsActivityJavaClass != null)
  2846.         {
  2847.             string speedMessage = gpsActivityJavaClass.CallStatic<string>("ChangeMode");
  2848.         }
  2849.     }
  2850. }
  2851.  
  2852. [Serializable]
  2853. public class FilledArea
  2854. {
  2855.     public float distance = 0;
  2856.     public float width = 0;
  2857. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!