public void CheckpointTriggered(CarController car, int checkPointIndex)
    {
        PositionData carData = _carPositions[car];

        if (!_finished)
        {
            if (checkPointIndex == 0)
            {
                if (carData.checkPoint == checkpointcount-1)
                {
                    carData.checkPoint = checkPointIndex;
                    carData.lap += 1;
                    Debug.Log(car.name + " lap " + carData.lap);
                    if (IsPlayer(car))
                    {
                        GetComponent<RaceManager>().Announce("Tour " + (carData.lap+1).ToString());
                    }

                    if (carData.lap >= _totalLaps)
                    {
                        _finished = true;
                        GetComponent<RaceManager>().EndRace(car.name.ToLower());
                    }
                }
            }
            else if (carData.checkPoint == checkPointIndex-1) //Checkpoints must be hit in order
            {
                carData.checkPoint = checkPointIndex;
            }
        }
    }

 void Start()
 {
     engineSource = GetComponents<AudioSource>()[0];
     skidSource = GetComponents<AudioSource>()[1];
     car = GetComponent (typeof (CarController)) as CarController;
     drivetrain = GetComponent (typeof (Drivetrain)) as Drivetrain;
 }

 void Awake()
 {
     // get the car controller
     renderer.enabled = false;
     car = transform.parent.gameObject.GetComponent<CarController>();
     rigidbody.position = car.rigidbody.position + Vector3.up * 5;
 }

        public void Index_GetCar()
        {
            var expectedResult = new[]
                {
                    new CarModel
                    {
                        CarId = 1,
                        Name = "Foo",
                        Color = "FooColor",
                        Price = 11111,
                        InventoryCount = 1,
                        Manufacturer = new ManufacturerModel
                        {
                            ManufacturerId = 1,
                            Country = "FooCountry",
                            Name = "FooManu"
                        }
                    }
                };
            var mockService = new Mock<ICarService>(MockBehavior.Strict);
            mockService.Setup(s => s.GetCar(expectedResult[0].CarId)).Returns(expectedResult[0]);

            var mockMapper = new Mock<Mappers.IMapper>(MockBehavior.Strict);
            mockMapper.Setup(m => m.Map(expectedResult, typeof(IEnumerable<CarModel>), typeof(IEnumerable<CarViewModel>)));

            var controller = new CarController(mockService.Object, mockMapper.Object);
            var result = controller.Index(false, expectedResult[0].CarId) as ViewResult;
            var model = result.Model as CarModel[];

            Assert.IsNotNull(model);
            mockService.Verify(foo => foo.GetCar(expectedResult[0].CarId));
        }

        public RealCar(CarController parent)
        {
            Controller = parent;
            CarInfo = new CarInformations();

            IsAlertBrakeActive = false;

            //regulators and communicator initiation
            CarComunicator = new RealCarCommunicator(this); // = new RealCarCommunicator(this);

            SpeedRegulator = new PIDSpeedRegulator(this);
            //SpeedRegulator = new FakeSpeedRegulator();

            //SteeringWheelAngleRegulator = new SimpleSteeringWheelRegulator(this);
            SteeringWheelAngleRegulator = new PIDSteeringWheelAngleRegulator(this);
            //SteeringWheelAngleRegulator = new FakeSteeringWheelRegulator();

            BrakeRegulator = new PIDBrakeRegulator(this);

            CarComunicator.InitRegulatorsEventsHandling();  //TODO: REFACTOR THIS SHIT!!! //for now this is needed, because reagulators does not exists when communicator constructor is invoked

            //internal event handling initialization
            evAlertBrake += new EventHandler(ExampleFakeCar_evAlertBrake);
            evTargetSpeedChanged += new TargetSpeedChangedEventHandler(ExampleFakeCar_evTargetSpeedChanged);
            evTargetSteeringWheelAngleChanged += new TargetSteeringWheelAngleChangedEventHandler(ExampleFakeCar_evTargetSteeringWheelAngleChanged);
        }

 void Start()
 {
     car = GetComponent<CarController>();
     transform.position = CurveFollower.transform.position;
     transform.rotation = CurveFollower.transform.rotation;
     CurveFollower.Speed = 0f;
 }

    // ==========================================
    // == Awake
    // ==========================================
    void Awake()
    {
        // get the car controller
        car = GetComponent<CarController>();

        styleManager = GetComponent<StyleManager>();
    }

    void Init()
    {
        _Sphere = GetComponent<SphereCollider>();
        _ShootingScript = GetComponent<ShootScript>();
        if (this.CompareTag("PlayerLogic"))
        {
            _PlayerCar = CarUserControl.Instance.m_Car;
        }
        else
        {
            _PlayerCar = GetComponent<CarController>();
        }

        if (_Weapons.Length != 0)
        {
            for (int i = 0; i < _Weapons.Length; i++)
            {
                _Weapons[i]._HitBox = _Weapons[i]._WeaponCollider.GetComponent<HitBox>();
                _Weapons[i]._Tower._HitBox = _Weapons[i]._Tower._TowerCollider.GetComponent<HitBox>();
                _Weapons[i]._WeaponTransform = transform.SearchChildWithName(_Weapons[i]._Name);
                _Weapons[i]._Tower._TowerTransform = transform.SearchChildWithName(_Weapons[i]._Tower._Name);
            }
        }

        _ShootingScript.Init();
    }

 void Awake()
 {
     _CarInfo = transform.root.GetComponent<CarInfo>();
     _Car = transform.root.GetComponent<CarController>();
     _Collider = GetComponent<Collider>();
     Counting();
 }

 void Start()
 {
     mTransform = transform;
     position = mTransform.position;
     rotation = mTransform.eulerAngles;
     car = CarController.instance;
 }

 // Use this for initialization
 void OnEnable()
 {
     previousGear = 1;
     if(carController == null)
         carController = transform.root.GetComponent<CarController>();
     carController.gearShiftEvent += OnGearShift;
 }

 public void SetCar(GameObject Car)
 {
     print("setcar "+Car);
     CurrentCar = Car;
     CC = Car.GetComponent<CarController>();
     CarPos = Car.transform.position;
 }

    bool IsPlayer(CarController car)
    {
        if (car == null)
            return false;

        return car.GetComponent<CarUserControlMP>() != null;
    }

 void Start()
 {
     engineSource = CreateAudioSource(engine);
     skidSource = CreateAudioSource(skid);
     car = GetComponent (typeof (CarController)) as CarController;
     drivetrain = GetComponent (typeof (Drivetrain)) as Drivetrain;
 }

 private void Awake()
 {
     // get the car controller
     m_Car = GetComponent<CarController>();
     screenWidth = Screen.width;
     m_Rigidbody = GetComponent<Rigidbody>();
 }

 // Use this for initialization
 void Start()
 {
     /*if (cameraType == cameraTypes.terceiraPessoa) {
         transform.SetParent(mainCar.transform);
     }*/
     mainCarController = mainCar.GetComponent<CarController> ();
     cameraIniPos = Camera.main.transform.localPosition;
 }

 void Awake()
 {
     stuckTimerCount = 0;
     city = GameObject.FindObjectOfType<CityManager>();
     controller = GetComponent<CarController> ();
     player = GameObject.FindGameObjectWithTag("Player").transform;
     GetComponentInChildren<UnityStandardAssets.Vehicles.Car.CarAIControl>().SetTarget(player);
 }

 void Start()
 {
     carController = GameObject.Find("MB300SL").GetComponent<CarController>();
     scroll = GetComponentInChildren<Scrollbar>();
     txt1 = GameObject.Find("Text_LeftRMP").GetComponent<Text>();
     txt2 = GameObject.Find("Text_RightRMP").GetComponent<Text>();
     but_rest = GameObject.Find("Restart").GetComponent<Button>();
 }

	float avoidPathOffset;			// direction (-1 or 1) in which to offset path to avoid other car, whilst avoiding

    void Awake ()
    {
        // get the car controller reference
        carController = GetComponent<CarController>();

        // give the random perlin a random value
		randomPerlin = Random.value*100;
    }

 //Anarchy script;
 // Use this for initialization
 void Start()
 {
     carusercontrol = GetComponent<CarUserControl> ();
     carcontroller = GetComponent<CarController> ();
     carselfrighting = GetComponent<CarSelfRighting> ();
     objectresetter = GetComponent<ObjectResetter> ();
     //script = GetComponent<Anarchy> ();
 }