private static void Prefix(CarDamageModel __instance, bool set)
 {
     if (NetworkManager.IsClient())
     {
         NetworkTrainPosSync posSync = __instance.trainCar.GetComponent <NetworkTrainPosSync>();
         if (posSync)
         {
             posSync.IsCarDamageEnabled = !set;
         }
     }
 }
        public static void ConvertPlayerSpawnedTrainCar(TrainCar trainCar)
        {
            if (!trainCar.playerSpawnedCar)
            {
                return;
            }

            trainCar.playerSpawnedCar = false;

            CarStateSave carStateSave = Traverse.Create(trainCar).Field("carStateSave").GetValue <CarStateSave>();

            if (Traverse.Create(carStateSave).Field("debtTrackerCar").GetValue <DebtTrackerCar>() != null)
            {
                return;
            }

            TrainCarPlatesController trainPlatesCtrl
                = Traverse.Create(trainCar).Field("trainPlatesCtrl").GetValue <TrainCarPlatesController>();

            CarDamageModel carDamage = Traverse.Create(trainCar).Field("carDmg").GetValue <CarDamageModel>();

            if (carDamage == null)
            {
                Debug.Log(string.Format(
                              "[PersistentJobs] Creating CarDamageModel for TrainCar[{0}]...",
                              trainCar.logicCar.ID));
                carDamage = trainCar.gameObject.AddComponent <CarDamageModel>();
                Traverse.Create(trainCar).Field("carDmg").SetValue(carDamage);
                carDamage.OnCreated(trainCar);
                Traverse.Create(trainPlatesCtrl)
                .Method("UpdateCarHealth", new Type[] { typeof(float) })
                .GetValue(carDamage.EffectiveHealthPercentage100Notation);
                carDamage.CarEffectiveHealthStateUpdate += carHealthPercentage => Traverse.Create(trainPlatesCtrl)
                                                           .Method("UpdateCarHealth", new Type[] { typeof(float) })
                                                           .GetValue(carHealthPercentage);
            }

            CargoDamageModel cargoDamage = trainCar.CargoDamage;

            if (cargoDamage == null && !trainCar.IsLoco)
            {
                Debug.Log(string.Format(
                              "[PersistentJobs] Creating CargoDamageModel for TrainCar[{0}]...",
                              trainCar.logicCar.ID));
                cargoDamage = trainCar.gameObject.AddComponent <CargoDamageModel>();
                Traverse.Create(trainCar).Property("cargoDamage").SetValue(cargoDamage);
                cargoDamage.OnCreated(trainCar);
                Traverse.Create(trainPlatesCtrl)
                .Method("UpdateCargoHealth", new Type[] { typeof(float) })
                .GetValue(cargoDamage.EffectiveHealthPercentage100Notation);
                cargoDamage.CargoEffectiveHealthStateUpdate += cargoHealthPercentage => Traverse.Create(trainPlatesCtrl)
                                                               .Method("UpdateCargoHealth", new Type[] { typeof(float) })
                                                               .GetValue(cargoHealthPercentage);
            }

            CarDebtController carDebtController
                = Traverse.Create(trainCar).Field("carDebtController").GetValue <CarDebtController>();

            carDebtController.SetDebtTracker(carDamage, cargoDamage);

            carStateSave.Initialize(carDamage, cargoDamage);
            carStateSave.SetDebtTrackerCar(carDebtController.CarDebtTracker);

            Debug.Log(string.Format("Converted player spawned TrainCar {0}", trainCar.logicCar.ID));
        }