FearLess Cheat Engine

Code: Select all

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using UnityEngine;

// Token: 0x02000470 RID: 1136
public class CheatShortcuts : MonoBehaviour
{
	// Token: 0x06001596 RID: 5526 RVA: 0x0000FF41 File Offset: 0x0000E141
	public void ApplyFuelConsumptions()
	{
		throw new NotImplementedException();
	}

	// Token: 0x06001597 RID: 5527 RVA: 0x0000FF41 File Offset: 0x0000E141
	public void ApplyReliability()
	{
		throw new NotImplementedException();
	}

	// Token: 0x17000399 RID: 921
	// (get) Token: 0x06001598 RID: 5528 RVA: 0x0000FF48 File Offset: 0x0000E148
	// (set) Token: 0x06001599 RID: 5529 RVA: 0x0000FF50 File Offset: 0x0000E150
	public bool Ready { get; private set; }

	// Token: 0x0600159A RID: 5530 RVA: 0x0000FF59 File Offset: 0x0000E159
	private void Awake()
	{
		if (Application.isEditor || Debug.isDebugBuild)
		{
			UnityEngine.Object.DontDestroyOnLoad(base.gameObject);
			return;
		}
		UnityEngine.Object.DontDestroyOnLoad(base.gameObject);
	}

	// Token: 0x0600159B RID: 5531 RVA: 0x00075B34 File Offset: 0x00073D34
	private void Start()
	{
		CheatShortcuts.<Start>d__16 <Start>d__;
		<Start>d__.<>t__builder = AsyncVoidMethodBuilder.Create();
		<Start>d__.<>4__this = this;
		<Start>d__.<>1__state = -1;
		<Start>d__.<>t__builder.Start<CheatShortcuts.<Start>d__16>(ref <Start>d__);
	}

	// Token: 0x0600159C RID: 5532 RVA: 0x0000FF80 File Offset: 0x0000E180
	private void Update()
	{
		this.ComputeGeneralShortcuts();
		this.ComputeHQShortcuts();
		this.ComputeRaceShortcuts();
	}

	// Token: 0x0600159D RID: 5533 RVA: 0x0000D4B0 File Offset: 0x0000B6B0
	private void OnDestroy()
	{
		Time.timeScale = 1f;
	}

	// Token: 0x0600159E RID: 5534 RVA: 0x00075B6C File Offset: 0x00073D6C
	private void ComputeGeneralShortcuts()
	{
		if (Input.GetKey(KeyCode.LeftAlt) && Input.GetKeyDown(KeyCode.B))
		{
			this.RestartApp();
		}
		if (Input.GetKeyDown(KeyCode.Space))
		{
			this.AccelerateTime(5f);
		}
		if (Input.GetKeyDown(KeyCode.F2))
		{
			this.AccelerateTime(15f);
		}
		if (Input.GetKeyUp(KeyCode.Space) || Input.GetKeyUp(KeyCode.F2))
		{
			this.ResetTime();
		}
		if (Input.GetKeyDown(KeyCode.S))
		{
			this.SlowTime();
		}
		if (Input.GetKeyUp(KeyCode.S))
		{
			this.ResetTime();
		}
		if (Input.GetKey(KeyCode.LeftShift) && Input.GetKeyDown(KeyCode.F))
		{
			this.SkipFTUE();
		}
	}

	// Token: 0x0600159F RID: 5535 RVA: 0x00075C14 File Offset: 0x00073E14
	private void ComputeHQShortcuts()
	{
		if (Input.GetKeyDown(KeyCode.P))
		{
			this.AddCash(1000000);
		}
		if (Input.GetKeyDown(KeyCode.M))
		{
			this.ResetAll();
		}
		if (Input.GetKeyDown(KeyCode.B))
		{
			this.SetAllDriverTo(1000);
		}
		if (Input.GetKeyDown(KeyCode.V))
		{
			this.CompleteResearch();
		}
		if (Input.GetKeyDown(KeyCode.N))
		{
			this.GoToNextMonthAndUpgradeItems();
		}
	}

	// Token: 0x060015A0 RID: 5536 RVA: 0x00075C78 File Offset: 0x00073E78
	private void ComputeRaceShortcuts()
	{
		if (Input.GetKey(KeyCode.LeftShift))
		{
			if (Input.GetKeyDown(KeyCode.T))
			{
				this.EndRace();
			}
			if (Input.GetKeyDown(KeyCode.F1))
			{
				this.IncidentLeftCar();
			}
			if (Input.GetKeyDown(KeyCode.F2))
			{
				this.IncidentRightCar();
			}
			if (Input.GetKeyDown(KeyCode.F3))
			{
				this.ModifyCarEngineTemperature(-10, 0);
			}
			if (Input.GetKeyDown(KeyCode.F4))
			{
				this.ModifyCarEngineTemperature(-10, 1);
			}
			if (Input.GetKeyDown(KeyCode.F5))
			{
				this.ModifyCarFuel(-10, 0);
			}
			if (Input.GetKeyDown(KeyCode.F6))
			{
				this.ModifyCarFuel(-10, 1);
			}
			if (Input.GetKeyDown(KeyCode.Y))
			{
				this.TriggerYellowFlag();
			}
			if (Input.GetKeyDown(KeyCode.U))
			{
				this.EndYellowFlag();
			}
		}
	}

	// Token: 0x060015A1 RID: 5537 RVA: 0x00075D3C File Offset: 0x00073F3C
	public void EndRace()
	{
		RaceStateController.Instance.RaceState.ForceCompleteDEBUG();
		for (int i = 0; i < ApplicationManager.Instance.RaceModel.MemoryAlignedCars.Length; i++)
		{
			ApplicationManager.Instance.RaceModel.RacingCarService.m_carsAI.SetCarFinished(i);
		}
		Debug.Log("<color=#f72585>[CHEAT] Force race ending.</color>");
	}

	// Token: 0x060015A2 RID: 5538 RVA: 0x00075D98 File Offset: 0x00073F98
	public void IncidentLeftCar()
	{
		int carIndex = ApplicationManager.Instance.RaceModel.Participants[ApplicationManager.Instance.PlayerModel.Id].Positions[0];
		ApplicationManager.Instance.RaceModel.RacingCarService.m_carsAI.IncidentCar(carIndex);
		Debug.Log("<color=#f72585>[CHEAT] Simulate an accident on the left car.</color>");
	}

	// Token: 0x060015A3 RID: 5539 RVA: 0x00075DF8 File Offset: 0x00073FF8
	public void IncidentRightCar()
	{
		int carIndex = ApplicationManager.Instance.RaceModel.Participants[ApplicationManager.Instance.PlayerModel.Id].Positions[1];
		ApplicationManager.Instance.RaceModel.RacingCarService.m_carsAI.IncidentCar(carIndex);
		Debug.Log("<color=#f72585>[CHEAT] Simulate an accident on the right car.</color>");
	}

	// Token: 0x060015A4 RID: 5540 RVA: 0x0000FF94 File Offset: 0x0000E194
	public void IncidentRandomCar()
	{
		ApplicationManager.Instance.RaceModel.RacingCarService.m_carsAI.IncidentCar(UnityEngine.Random.Range(0, 17));
		Debug.Log("<color=#f72585>[CHEAT] Simulate an accident on the right car.</color>");
	}

	// Token: 0x060015A5 RID: 5541 RVA: 0x00075E58 File Offset: 0x00074058
	public void ModifyCarFuel(int amount, int carIndex)
	{
		PlayerModel playerModel = ApplicationManager.Instance.PlayerModel;
		ApplicationManager.Instance.RaceModel.MemoryAlignedRacingGas[ApplicationManager.Instance.RaceModel.Participants[playerModel.Id].Positions[carIndex]].currentCapacity += (float)amount;
		ApplicationManager.Instance.RaceModel.MemoryAlignedRacingGas[ApplicationManager.Instance.RaceModel.Participants[playerModel.Id].Positions[carIndex]].normalizedCapacity += (float)amount;
	}

	// Token: 0x060015A6 RID: 5542 RVA: 0x00075EF8 File Offset: 0x000740F8
	public void ModifyCarEngineTemperature(int amount, int carIndex)
	{
		PlayerModel playerModel = ApplicationManager.Instance.PlayerModel;
		ApplicationManager.Instance.RaceModel.MemoryAlignedRacingReliability[ApplicationManager.Instance.RaceModel.Participants[playerModel.Id].Positions[carIndex]].ForceUpdateTemperature(amount);
	}

	// Token: 0x060015A7 RID: 5543 RVA: 0x00075F4C File Offset: 0x0007414C
	public void ModifyTireDegradation(float amount, int carIndex)
	{
		PlayerModel playerModel = ApplicationManager.Instance.PlayerModel;
		ApplicationManager.Instance.RaceModel.MemoryAlignedRacingTires[ApplicationManager.Instance.RaceModel.Participants[playerModel.Id].Positions[carIndex]].ForceUpdateTireDegradation(amount);
	}

	// Token: 0x060015A8 RID: 5544 RVA: 0x00075FA0 File Offset: 0x000741A0
	public void ModifyTireTemperature(float amount, int carIndex)
	{
		PlayerModel playerModel = ApplicationManager.Instance.PlayerModel;
		ApplicationManager.Instance.RaceModel.MemoryAlignedRacingTires[ApplicationManager.Instance.RaceModel.Participants[playerModel.Id].Positions[carIndex]].ForceUpdateTireTemperature(amount);
	}

	// Token: 0x060015A9 RID: 5545 RVA: 0x00075FF4 File Offset: 0x000741F4
	public void ModifyStamina(float amount, int carIndex)
	{
		PlayerModel playerModel = ApplicationManager.Instance.PlayerModel;
		ApplicationManager.Instance.RaceModel.MemoryAlignedRacingStamina[ApplicationManager.Instance.RaceModel.Participants[playerModel.Id].Positions[carIndex]].ForceUpdateStamina(amount);
	}

	// Token: 0x060015AA RID: 5546 RVA: 0x0000FFC1 File Offset: 0x0000E1C1
	public void TriggerYellowFlag()
	{
		Debug.Log("<color=yellow>[Car Incidents] Yellow Flag !</color>");
		EventService.Instance.TriggerEvent(new OnRaceYellowFlag(true, ApplicationManager.Instance.RaceModel.FCYTime, 0));
	}

	// Token: 0x060015AB RID: 5547 RVA: 0x0000FFED File Offset: 0x0000E1ED
	public void EndYellowFlag()
	{
		Singleton<FCYController>.Instance.ForceYellowFlagEnd();
		Debug.Log("<color=#f72585>[CHEAT] Force end yellow flag.</color>");
	}

	// Token: 0x060015AC RID: 5548 RVA: 0x00010003 File Offset: 0x0000E203
	public void StartAllCars()
	{
		ApplicationManager.Instance.RaceModel.StartAllCarsDebug();
		Debug.Log("<color=#f72585>[CHEAT] Start all cars.</color>");
	}

	// Token: 0x060015AD RID: 5549 RVA: 0x0001001E File Offset: 0x0000E21E
	public void StopAllCars()
	{
		ApplicationManager.Instance.RaceModel.StopAllCarsDebug();
		Debug.Log("<color=#f72585>[CHEAT] Stop all cars.</color>");
	}

	// Token: 0x060015AE RID: 5550 RVA: 0x00010039 File Offset: 0x0000E239
	public void StartCar(int carIndex)
	{
		ApplicationManager.Instance.RaceModel.StartCarDebug(carIndex);
		Debug.Log(string.Format("<color=#f72585>[CHEAT] Starting car #{0}.</color>", carIndex));
	}

	// Token: 0x060015AF RID: 5551 RVA: 0x00010060 File Offset: 0x0000E260
	public void StopCar(int carIndex)
	{
		ApplicationManager.Instance.RaceModel.StopCarDebug(carIndex);
		Debug.Log(string.Format("<color=#f72585>[CHEAT] Stopping car #{0}.</color>", carIndex));
	}

	// Token: 0x060015B0 RID: 5552 RVA: 0x00010087 File Offset: 0x0000E287
	public void SetLastTurnForAllCars()
	{
		ApplicationManager.Instance.RaceModel.RacingCarService.m_carsAI.LastTurnForEveryCars();
		Debug.Log("<color=#f72585>[CHEAT] All cars are set to last turn.</color>");
	}

	// Token: 0x060015B1 RID: 5553 RVA: 0x000100AC File Offset: 0x0000E2AC
	public void IncrementPlayerCarFinishCount()
	{
		RaceStateController.Instance.RaceState.IncrementCarFinishedDEBUG();
		Debug.Log("<color=#f72585>[CHEAT] Car finish count incremented.</color>");
	}

	// Token: 0x060015B2 RID: 5554 RVA: 0x000100C7 File Offset: 0x0000E2C7
	public void ForceSpecificWeather(Weather weather)
	{
		WeatherCondition.Instance.ForceSpecificWeather(weather);
	}

	// Token: 0x060015B3 RID: 5555 RVA: 0x000100D4 File Offset: 0x0000E2D4
	public void SlowTime()
	{
		Time.timeScale = 0.5f;
		Debug.Log("<color=#f72585>[CHEAT] Time scale to 0.5.</color>");
	}

	// Token: 0x060015B4 RID: 5556 RVA: 0x000100EA File Offset: 0x0000E2EA
	public void ResetTime()
	{
		Time.timeScale = 1f;
		Debug.Log("<color=#f72585>[CHEAT] Time scale to 1.</color>");
	}

	// Token: 0x060015B5 RID: 5557 RVA: 0x00010100 File Offset: 0x0000E300
	public void AccelerateTime(float timeScale)
	{
		Time.timeScale = timeScale;
		Debug.Log(string.Format("<color=#f72585>[CHEAT] Time scale to {0}.</color>", timeScale));
	}

	// Token: 0x060015B6 RID: 5558 RVA: 0x0001011D File Offset: 0x0000E31D
	public void RestartApp()
	{
		Singleton<UserService>.Instance.RestartApp();
		Debug.Log("<color=#f72585>[CHEAT] Force app restart.</color>");
	}

	// Token: 0x060015B7 RID: 5559 RVA: 0x00076048 File Offset: 0x00074248
	public void SkipFTUE()
	{
		FTUEManager ftuemanager = UnityEngine.Object.FindObjectOfType<FTUEManager>();
		if (!ftuemanager)
		{
			Debug.Log("<color=#f72585>[CHEAT] No FTUE manager found.</color>");
			return;
		}
		ftuemanager.ForceFTUEEnd();
		Debug.Log("<color=#f72585>[CHEAT] FTUE by passed.</color>");
	}

	// Token: 0x060015B8 RID: 5560 RVA: 0x00010133 File Offset: 0x0000E333
	public void GoToNextMonth()
	{
		this._currentChampionship.MoveToNextRace();
		Debug.Log("<color=#f72585>[CHEAT] Travel one month into the future.</color>");
	}

	// Token: 0x060015B9 RID: 5561 RVA: 0x00076080 File Offset: 0x00074280
	public void GoToNextMonthAndUpgradeItems()
	{
		this.GoToNextMonth();
		User user = Singleton<UserService>.Instance.User;
		int num = user.TotalRaceCompeted;
		user.TotalRaceCompeted = num + 1;
		User user2 = Singleton<UserService>.Instance.User;
		num = user2.TodayRaceCompeted;
		user2.TodayRaceCompeted = num + 1;
		User user3 = Singleton<UserService>.Instance.User;
		num = user3.TotalRankedRacesCompeted;
		user3.TotalRankedRacesCompeted = num + 1;
		User user4 = Singleton<UserService>.Instance.User;
		num = user4.TotalRankedRaces;
		user4.TotalRankedRaces = num + 1;
		User user5 = Singleton<UserService>.Instance.User;
		num = user5.TotalRaceWon;
		user5.TotalRaceWon = num + 1;
		User user6 = Singleton<UserService>.Instance.User;
		num = user6.TotalRankedRacesWon;
		user6.TotalRankedRacesWon = num + 1;
		Singleton<UserService>.Instance.RequestSaveUser();
		Singleton<UserService>.Instance.ProgressionAddRaceInCategory(this._currentChampionship.GtCategory, 50);
		Singleton<UserService>.Instance.UpgradeItems(50);
	}

	// Token: 0x060015BA RID: 5562 RVA: 0x0001014A File Offset: 0x0000E34A
	public void RemoveCash(int amount)
	{
		Singleton<EconomyService>.Instance.RemoveCash(amount, FinancialDataSO.ExpenseType.ResearchAndScouting);
		Debug.Log("<color=#f72585>[CHEAT] Removing 10000$ from Sponsors Race Points.</color>");
	}

	// Token: 0x060015BB RID: 5563 RVA: 0x00010162 File Offset: 0x0000E362
	public void AddCash(int amount)
	{
		Singleton<EconomyService>.Instance.AddCash(amount, FinancialDataSO.IncomeType.RaceSponsorsRacePoints);
		Debug.Log("<color=#f72585>[CHEAT] Adding 10000$ to Sponsors Race Points.</color>");
	}

	// Token: 0x060015BC RID: 5564 RVA: 0x00076158 File Offset: 0x00074358
	public void OpenPractice()
	{
		GameObject gameObject = UnityEngine.Object.FindObjectOfType<HQPanel>(true).gameObject;
		gameObject.SetActive(true);
		for (int i = 0; i < gameObject.transform.childCount; i++)
		{
			if (gameObject.transform.GetChild(i).name == "Parent")
			{
				gameObject.transform.GetChild(i).gameObject.SetActive(true);
			}
		}
		UnityEngine.Object.FindObjectOfType<PracticePanel>(true).gameObject.SetActive(true);
	}

	// Token: 0x060015BD RID: 5565 RVA: 0x0001017A File Offset: 0x0000E37A
	public void UnlockAllItems()
	{
		Singleton<UserService>.Instance.UnlockAllItems();
		Debug.Log("<color=#f72585>[CHEAT] All items has been unlocked. Remember: 'Un grand pouvoir implique de grandes responsabilités'</color>");
	}

	// Token: 0x060015BE RID: 5566 RVA: 0x000761D4 File Offset: 0x000743D4
	public void CompleteResearch()
	{
		IEnumerable<Item> searchedItems = Singleton<UserService>.Instance.GetSearchedItems();
		Singleton<UserService>.Instance.CompleteSearch(searchedItems.First<Item>());
	}

	// Token: 0x060015BF RID: 5567 RVA: 0x000761FC File Offset: 0x000743FC
	public void SimulateCollision()
	{
		int num = UnityEngine.Random.Range(0, 16);
		ApplicationManager.Instance.RaceModel.RacingCarService.m_carsAI.SimulateCollision(num, num + 1, num);
	}

	// Token: 0x060015C0 RID: 5568 RVA: 0x00010190 File Offset: 0x0000E390
	public void SimulateOufOfTrack()
	{
		ApplicationManager.Instance.RaceModel.RacingCarService.m_carsAI.SimulateOutOfTrack(UnityEngine.Random.Range(0, 16));
	}

	// Token: 0x060015C1 RID: 5569 RVA: 0x00076230 File Offset: 0x00074430
	public void ResetAll()
	{
		this.ResetCar1Stats();
		this.ResetCar2Stats();
		this.ResetDriver1Stats();
		this.ResetDriver2Stats();
		this.ResetDriver3Stats();
		this.ResetDriver4Stats();
		this.ApplyCar1Stats();
		this.ApplyCar2Stats();
		this.ApplyDriver1Stats();
		this.ApplyDriver2Stats();
		this.ApplyDriver3Stats();
		this.ApplyDriver4Stats();
	}

	// Token: 0x060015C2 RID: 5570 RVA: 0x000101B3 File Offset: 0x0000E3B3
	public void SetAllCarTo(int value)
	{
		this._car1Acceleration = value;
		this._car1TopSpeed = value;
		this._car1Handling = value;
		this._car1TireDegradation = value;
		this._car2Acceleration = value;
		this._car2TopSpeed = value;
		this._car2Handling = value;
		this._car2TireDegradation = value;
	}

	// Token: 0x060015C3 RID: 5571 RVA: 0x00076288 File Offset: 0x00074488
	public void SetAllDriverTo(int value)
	{
		this._driver1Speed = value;
		this._driver1WetSpeed = value;
		this._driver1Overtaking = value;
		this._driver1Consistency = value;
		this._driver2Speed = value;
		this._driver2WetSpeed = value;
		this._driver2Overtaking = value;
		this._driver2Consistency = value;
		this._driver3Speed = value;
		this._driver3WetSpeed = value;
		this._driver3Overtaking = value;
		this._driver3Consistency = value;
		this._driver4Speed = value;
		this._driver4WetSpeed = value;
		this._driver4Overtaking = value;
		this._driver4Consistency = value;
	}

	// Token: 0x060015C4 RID: 5572 RVA: 0x00076308 File Offset: 0x00074508
	public void ResetCar1Stats()
	{
		CarInventory.CarStats carStatsWithCurrentInventory = Singleton<UserService>.Instance.GetCarStatsWithCurrentInventory();
		this._car1Acceleration = 1000 * carStatsWithCurrentInventory.Acceleration;
		this._car1TopSpeed = 1000 * carStatsWithCurrentInventory.TopSpeed;
		this._car1Handling = 1000 * carStatsWithCurrentInventory.Handling;
		this._car1TireDegradation = 1000 * carStatsWithCurrentInventory.TireDegradation;
	}

	// Token: 0x060015C5 RID: 5573 RVA: 0x00076368 File Offset: 0x00074568
	public void ResetCar2Stats()
	{
		CarInventory.CarStats carStatsWithCurrentInventory = Singleton<UserService>.Instance.GetCarStatsWithCurrentInventory();
		this._car2Acceleration = 1000 * carStatsWithCurrentInventory.Acceleration;
		this._car2TopSpeed = 1000 * carStatsWithCurrentInventory.TopSpeed;
		this._car2Handling = 1000 * carStatsWithCurrentInventory.Handling;
		this._car2TireDegradation = 1000 * carStatsWithCurrentInventory.TireDegradation;
	}

	// Token: 0x060015C6 RID: 5574 RVA: 0x000763C8 File Offset: 0x000745C8
	public void ResetDriver1Stats()
	{
		Item driver;
		Singleton<UserService>.Instance.TryGetDriverItem(BuildingType.FIRST_DRIVER, 0, out driver);
		TransferDriverStats transferDriverStats = new TransferDriverStats(driver);
		this._driver1Speed = 100 * (int)transferDriverStats.Velocity;
		this._driver1WetSpeed = 100 * (int)transferDriverStats.WetVelocity;
		this._driver1Overtaking = 100 * (int)transferDriverStats.Overtaking;
		this._driver1Consistency = 100 * (int)transferDriverStats.Consistency;
	}

	// Token: 0x060015C7 RID: 5575 RVA: 0x0007642C File Offset: 0x0007462C
	public void ResetDriver2Stats()
	{
		Item driver;
		Singleton<UserService>.Instance.TryGetDriverItem(BuildingType.FIRST_DRIVER, 1, out driver);
		TransferDriverStats transferDriverStats = new TransferDriverStats(driver);
		this._driver2Speed = 100 * (int)transferDriverStats.Velocity;
		this._driver2WetSpeed = 100 * (int)transferDriverStats.WetVelocity;
		this._driver2Overtaking = 100 * (int)transferDriverStats.Overtaking;
		this._driver2Consistency = 100 * (int)transferDriverStats.Consistency;
	}

	// Token: 0x060015C8 RID: 5576 RVA: 0x00076490 File Offset: 0x00074690
	public void ResetDriver3Stats()
	{
		Item driver;
		Singleton<UserService>.Instance.TryGetDriverItem(BuildingType.SECOND_DRIVER, 0, out driver);
		TransferDriverStats transferDriverStats = new TransferDriverStats(driver);
		this._driver3Speed = 100 * (int)transferDriverStats.Velocity;
		this._driver3WetSpeed = 100 * (int)transferDriverStats.WetVelocity;
		this._driver3Overtaking = 100 * (int)transferDriverStats.Overtaking;
		this._driver3Consistency = 100 * (int)transferDriverStats.Consistency;
	}

	// Token: 0x060015C9 RID: 5577 RVA: 0x000764F4 File Offset: 0x000746F4
	public void ResetDriver4Stats()
	{
		Item driver;
		Singleton<UserService>.Instance.TryGetDriverItem(BuildingType.SECOND_DRIVER, 1, out driver);
		TransferDriverStats transferDriverStats = new TransferDriverStats(driver);
		this._driver4Speed = 100 * (int)transferDriverStats.Velocity;
		this._driver4WetSpeed = 100 * (int)transferDriverStats.WetVelocity;
		this._driver4Overtaking = 100 * (int)transferDriverStats.Overtaking;
		this._driver4Consistency = 100 * (int)transferDriverStats.Consistency;
	}

	// Token: 0x060015CA RID: 5578 RVA: 0x00076558 File Offset: 0x00074758
	public void ApplyCar1Stats()
	{
		Dictionary<CAR_STAT, int> carSetup = new Dictionary<CAR_STAT, int>
		{
			{
				CAR_STAT.ACCELERATION,
				this._car1Acceleration
			},
			{
				CAR_STAT.TOP_SPEED,
				this._car1TopSpeed
			},
			{
				CAR_STAT.TYRE_DEGRADATION,
				this._car1TireDegradation
			},
			{
				CAR_STAT.HANDLING,
				this._car1Handling
			}
		};
		Debug.Log(string.Format("<color=#f72585>[CHEAT] Overriding car 1 stats: Acceleration: {0}, Top Speed: {1}, Handling: {2}, Tire Degradation: {3}.</color>", new object[]
		{
			this._car1Acceleration,
			this._car1TopSpeed,
			this._car1Handling,
			this._car1TireDegradation
		}));
		ApplicationManager.Instance.RaceModel.ApplyNewCarStatsDebug(0, carSetup);
	}

	// Token: 0x060015CB RID: 5579 RVA: 0x00076600 File Offset: 0x00074800
	public void ApplyCar2Stats()
	{
		Dictionary<CAR_STAT, int> carSetup = new Dictionary<CAR_STAT, int>
		{
			{
				CAR_STAT.ACCELERATION,
				this._car2Acceleration
			},
			{
				CAR_STAT.TOP_SPEED,
				this._car2TopSpeed
			},
			{
				CAR_STAT.TYRE_DEGRADATION,
				this._car2TireDegradation
			},
			{
				CAR_STAT.HANDLING,
				this._car2Handling
			}
		};
		Debug.Log(string.Format("<color=#f72585>[CHEAT] Overriding car 2 stats: Acceleration: {0}, Top Speed: {1}, Handling: {2}, Tire Degradation: {3}.</color>", new object[]
		{
			this._car2Acceleration,
			this._car2TopSpeed,
			this._car2Handling,
			this._car2TireDegradation
		}));
		ApplicationManager.Instance.RaceModel.ApplyNewCarStatsDebug(1, carSetup);
	}

	// Token: 0x060015CC RID: 5580 RVA: 0x000766A8 File Offset: 0x000748A8
	public void ApplyDriver1Stats()
	{
		Dictionary<DRIVER_STAT, float> driverSetup = new Dictionary<DRIVER_STAT, float>
		{
			{
				DRIVER_STAT.VELOCITY,
				(float)this._driver1Speed
			},
			{
				DRIVER_STAT.OVERTAKING,
				(float)this._driver1Overtaking
			},
			{
				DRIVER_STAT.WET_VELOCITY,
				(float)this._driver1WetSpeed
			},
			{
				DRIVER_STAT.CONSISTENCY,
				(float)this._driver1Consistency
			}
		};
		Debug.Log(string.Format("<color=#f72585>[CHEAT] Overriding car 1, driver 1 stats: Speed: {0}, Overtaking: {1}, Wet Speed: {2}, Consistency: {3}.</color>", new object[]
		{
			this._driver1Speed,
			this._driver1Overtaking,
			this._driver1WetSpeed,
			this._driver1Consistency
		}));
		ApplicationManager.Instance.RaceModel.ApplyNewDriverStatsDebug(0, 0, driverSetup);
	}

	// Token: 0x060015CD RID: 5581 RVA: 0x00076754 File Offset: 0x00074954
	public void ApplyDriver2Stats()
	{
		Dictionary<DRIVER_STAT, float> driverSetup = new Dictionary<DRIVER_STAT, float>
		{
			{
				DRIVER_STAT.VELOCITY,
				(float)this._driver2Speed
			},
			{
				DRIVER_STAT.OVERTAKING,
				(float)this._driver2Overtaking
			},
			{
				DRIVER_STAT.WET_VELOCITY,
				(float)this._driver2WetSpeed
			},
			{
				DRIVER_STAT.CONSISTENCY,
				(float)this._driver2Consistency
			}
		};
		Debug.Log(string.Format("<color=#f72585>[CHEAT] Overriding car 1, driver 2 stats: Speed: {0}, Overtaking: {1}, Wet Speed: {2}, Consistency: {3}.</color>", new object[]
		{
			this._driver2Speed,
			this._driver2Overtaking,
			this._driver2WetSpeed,
			this._driver2Consistency
		}));
		ApplicationManager.Instance.RaceModel.ApplyNewDriverStatsDebug(0, 1, driverSetup);
	}

	// Token: 0x060015CE RID: 5582 RVA: 0x00076800 File Offset: 0x00074A00
	public void ApplyDriver3Stats()
	{
		Dictionary<DRIVER_STAT, float> driverSetup = new Dictionary<DRIVER_STAT, float>
		{
			{
				DRIVER_STAT.VELOCITY,
				(float)this._driver3Speed
			},
			{
				DRIVER_STAT.OVERTAKING,
				(float)this._driver3Overtaking
			},
			{
				DRIVER_STAT.WET_VELOCITY,
				(float)this._driver3WetSpeed
			},
			{
				DRIVER_STAT.CONSISTENCY,
				(float)this._driver3Consistency
			}
		};
		Debug.Log(string.Format("<color=#f72585>[CHEAT] Overriding car 2, driver 1 stats: Speed: {0}, Overtaking: {1}, Wet Speed: {2}, Consistency: {3}.</color>", new object[]
		{
			this._driver3Speed,
			this._driver3Overtaking,
			this._driver3WetSpeed,
			this._driver3Consistency
		}));
		ApplicationManager.Instance.RaceModel.ApplyNewDriverStatsDebug(1, 0, driverSetup);
	}

	// Token: 0x060015CF RID: 5583 RVA: 0x000768AC File Offset: 0x00074AAC
	public void ApplyDriver4Stats()
	{
		Dictionary<DRIVER_STAT, float> driverSetup = new Dictionary<DRIVER_STAT, float>
		{
			{
				DRIVER_STAT.VELOCITY,
				(float)this._driver4Speed
			},
			{
				DRIVER_STAT.OVERTAKING,
				(float)this._driver4Overtaking
			},
			{
				DRIVER_STAT.WET_VELOCITY,
				(float)this._driver4WetSpeed
			},
			{
				DRIVER_STAT.CONSISTENCY,
				(float)this._driver4Consistency
			}
		};
		Debug.Log(string.Format("<color=#f72585>[CHEAT] Overriding car 2, driver 2 stats: Speed: {0}, Overtaking: {1}, Wet Speed: {2}, Consistency: {3}.</color>", new object[]
		{
			this._driver4Speed,
			this._driver4Overtaking,
			this._driver4WetSpeed,
			this._driver4Consistency
		}));
		ApplicationManager.Instance.RaceModel.ApplyNewDriverStatsDebug(1, 1, driverSetup);
	}

	// Token: 0x0400181C RID: 6172
	public float _preserveFuelConsumption;

	// Token: 0x0400181D RID: 6173
	public float _standardFuelConsumption;

	// Token: 0x0400181E RID: 6174
	public float _pushFuelConsumption;

	// Token: 0x0400181F RID: 6175
	public float _pushToPassFuelConsumption;

	// Token: 0x04001820 RID: 6176
	public float _preserveReliabilityModifier;

	// Token: 0x04001821 RID: 6177
	public float _standardReliabilityModifier;

	// Token: 0x04001822 RID: 6178
	public float _pushReliabilityModifier;

	// Token: 0x04001823 RID: 6179
	public float _pushToPassReliabilityModifier;

	// Token: 0x04001824 RID: 6180
	[SerializeField]
	private CurrentChampionshipSO _currentChampionship;

	// Token: 0x04001826 RID: 6182
	public int _car1Acceleration = 50;

	// Token: 0x04001827 RID: 6183
	public int _car1TopSpeed = 50;

	// Token: 0x04001828 RID: 6184
	public int _car1Handling = 50;

	// Token: 0x04001829 RID: 6185
	public int _car1TireDegradation = 50;

	// Token: 0x0400182A RID: 6186
	public int _car2Acceleration = 50;

	// Token: 0x0400182B RID: 6187
	public int _car2TopSpeed = 50;

	// Token: 0x0400182C RID: 6188
	public int _car2Handling = 50;

	// Token: 0x0400182D RID: 6189
	public int _car2TireDegradation = 50;

	// Token: 0x0400182E RID: 6190
	public int _driver1Speed = 50;

	// Token: 0x0400182F RID: 6191
	public int _driver1WetSpeed = 50;

	// Token: 0x04001830 RID: 6192
	public int _driver1Overtaking = 50;

	// Token: 0x04001831 RID: 6193
	public int _driver1Consistency = 50;

	// Token: 0x04001832 RID: 6194
	public int _driver2Speed = 50;

	// Token: 0x04001833 RID: 6195
	public int _driver2WetSpeed = 50;

	// Token: 0x04001834 RID: 6196
	public int _driver2Overtaking = 50;

	// Token: 0x04001835 RID: 6197
	public int _driver2Consistency = 50;

	// Token: 0x04001836 RID: 6198
	public int _driver3Speed = 50;

	// Token: 0x04001837 RID: 6199
	public int _driver3WetSpeed = 50;

	// Token: 0x04001838 RID: 6200
	public int _driver3Overtaking = 50;

	// Token: 0x04001839 RID: 6201
	public int _driver3Consistency = 50;

	// Token: 0x0400183A RID: 6202
	public int _driver4Speed = 50;

	// Token: 0x0400183B RID: 6203
	public int _driver4WetSpeed = 50;

	// Token: 0x0400183C RID: 6204
	public int _driver4Overtaking = 50;

	// Token: 0x0400183D RID: 6205
	public int _driver4Consistency = 50;
}