void Awake()
{
freeCars = new CarData[4];
for (int i = 0; i < 4; i++)
{
freeCars[i] = new CarData();
}
spawnedCars = new List <CarData> [4];
for (int i = 0; i < 4; i++)
{
spawnedCars[i] = new List <CarData>();
}
play = false;
free = true;
StartCursorPos = 0;
carManager = gameObject.GetComponent <CarManager>();
carManager.data = spawnedCars;
carManager.furtherCar = new CarData(cursorCar.gameObject, 0, 0, Type.car, 0);
selectedCar = new CarData();
type = Type.car;
line = 0;
cursorCar.transform.GetChild(0).animation.wrapMode = WrapMode.Loop;
dl = new DataLoader(inTheForest);
dm = new DataManager(spawnedCars, inTheForest);
}
/// <summary>
/// Swaps the data of two list elements
/// </summary>
/// <param name="firstElement">first element to swap</param>
/// <param name="secondElement">second element to swap</param>
private void SwapElements(ListElement firstElement, ListElement secondElement)
{
CarData temp = firstElement.Data;
firstElement.Data = secondElement.Data;
secondElement.Data = temp;
}
private bool ChangeMaxDist()
{
float maxTime = 0;
for (int i = 0; i < 4; i++)
{
for (int k = 0; k < data[i].Count; k++)
{
if (((data[i][k].dist + 86) / data[i][k].carspeed) >= maxTime && data[i][k].carspeed != 0)
{
maxTime = ((data[i][k].dist + 86) / data[i][k].carspeed);
furtherCar = data[i][k];
}
}
}
if (!furtherCar.entity)
{
print("no cars in scene");
gameObject.GetComponent <CarSpawner>().Stop();
return(false);
}
else
{
return(true);
}
}
public FeaturedController(IOptions <AppSettings> appSettings)
{
_appSettings = appSettings.Value;
_cardata = new CarData(_appSettings.CarWaleApiBaseURL);
_carviewContext = new CarviewContext();
_imageBaseURL = _appSettings.CarWaleApiBaseURL + _imageURLPath;
}
public CarTrafficData(string fileName)
{
string line;
int idx = 0;
System.IO.StreamReader file = new System.IO.StreamReader(fileName);
while ((line = file.ReadLine()) != null)
{
if (idx == 0)
{
numSegments = int.Parse(line);
}
else if (idx == 1)
{
numCars = int.Parse(line);
}
else
{
blocked = new bool[numSegments];
string[] startEndData = line.Split(',');
CarData data = new CarData();
data.id = idx - 2;
data.start = int.Parse(startEndData[0]);
data.end = int.Parse(startEndData[1]);
data.estimatedArrival = int.Parse(startEndData[2]);
data.startingTime = Math.Max(1, data.estimatedArrival - ((data.end - data.start)) - 20);
data.current = data.start;
blocked[data.current] = true;
cars.Add(data);
}
++idx;
}
}
public void SetCarChoice(int carNum, bool isMultiplayer)
{
CarData data = CarDataLookup.Instance.FindCarData(carStyle);
upgradeLevel = (UpgradeLevel)carNum;
if (data != null)
{
SpriteRenderer visual = GetComponentInChildren <SpriteRenderer>();
if (visual)
{
visual.sprite = data.GetVisual(carColor);
}
PolygonCollider2D collider = GetComponentInChildren <PolygonCollider2D>();
if (collider != null)
{
collider.SetPath(0, data.points.ToArray());
}
if (isMultiplayer)
{
// Car choice has only a visual effect in multiplayer games
_carSpeed = data.GetMaxSpeed(0);
}
else
{
_carSpeed = data.GetMaxSpeed(carNum - 1);
}
}
}
public List <CarData> AddLap(CarData car)
{
if (laps.ContainsKey(car))
{
laps[car] += 1;
}
else
{
laps.Add(car, 1);
standings.Add(car);
Debug.Log("The " + car.number + " car was just added to the standings, so it's put at the end.");
return(standings);
}
standings.Remove(car);
for (int i = 0; i < standings.Count; i++)
{
if (laps[standings[i]] < laps[car])
{
Debug.Log(car.number + " has more laps than car number " + standings[i].number);
standings.Insert(i, car);
Debug.Log("The " + car.number + " is ahead of the " + standings[i + 1].number + " car. It's put ahead of it.");
return(standings);
}
}
standings.Add(car);
Debug.Log("The " + car.number + " is last.");
return(standings);
}
public void SetCarSelected(int index)
{
for (int i = 0; i < carsInList.Count; i++) {
if (i == index)
carsInList [i].SBA.ResetBlinkingAnimation ();
else
carsInList [i].SBA.gameObject.SetActive (false);
}
CarData readedCar = GlobalGameData.currentInstance.m_playerData_carsOwned [index];
carNameText.text = readedCar.GetCarName ();
statSliders[0].SetValues (readedCar.GetBaseMaxSpeed(), readedCar.GetUpgradedMaxSpeed());
statSliders[1].SetValues (readedCar.GetBaseAcceleration(), readedCar.GetUpgradedAcceleration());
statSliders[2].SetValues (readedCar.GetBaseTurnRate(), readedCar.GetUpgradedTurnRate());
statSliders[3].SetValues (readedCar.GetBaseDriftStrenght(), readedCar.GetUpgradedDriftStrenght());
statSliders[4].SetValues (readedCar.GetBaseWeight (), readedCar.GetUpgradedWeight ());
ChangeCarDisplayed (true, readedCar.GetSkinId ());
carInDisplayIndex = index;
MainMenuSoundManager.instance.playAcceptSound ();
}
private void ReadSerial(object data)
{
CarData d = ((CarData)data);
CarTime newest;
String message;
while (d.run)
{
try
{
message = d.usb.ReadLine();
newest = d.data.FirstOrDefault(dd => dd.Stop == null);
if (newest != null)
{
newest.Stop = message;
}
else
{
Console.WriteLine($"Found a time with no match: {message}");
}
}
catch (Exception ex)
{
if (ex.Message != "The operation has timed out.")
{
Console.WriteLine(ex.Message);
}
continue;
//nothing to do, just means nothing on the serial
}
}
}
public CarData GetItem(string carName, string carModel, string carEngine)
{
try
{
DBbase.Connect();
string sql = @"SELECT CAR_ID,CAR_CODE,CAR_NAME,CAR_MODEL,CAR_ENGINE,CAR_REMARK,CAR_STATUS FROM MA_CAR WHERE
CAR_NAME = '" + carName + "' AND CAR_MODEL = '" + carModel + "' AND CAR_ENGINE = '" + carEngine + "'";
SqlCommand cmd = new SqlCommand(sql, DBbase.con);
SqlDataReader reader = cmd.ExecuteReader();
if (reader.Read())
{
CarData item = new CarData();
item.CAR_ID = Convert.ToInt32(reader["CAR_ID"].ToString());
item.CAR_CODE = reader["CAR_CODE"].ToString();
item.CAR_NAME = reader["CAR_NAME"].ToString();
item.CAR_MODEL = reader["CAR_MODEL"].ToString();
item.CAR_ENGINE = reader["CAR_ENGINE"].ToString();
item.CAR_REMARK = reader["CAR_REMARK"].ToString();
item.CAR_STATUS = reader["CAR_STATUS"].ToString();
reader.Close();
DBbase.DisConnect();
return(item);
}
else
{
DBbase.DisConnect();
return(null);
}
}
catch (Exception ex)
{
throw ex;
}
}
public void Update(CarData oldItem, CarData newItem)
{
try
{
MemberData member = (MemberData)DataCommon.Get("DATA.MEMBER");
DBbase.Connect();
StringBuilder sql = new StringBuilder();
sql.Append("UPDATE MA_CAR SET CAR_CODE = '" + newItem.CAR_CODE + "',");
sql.Append(" CAR_ENGINE = '" + newItem.CAR_ENGINE + "',");
sql.Append(" CAR_MODEL = '" + newItem.CAR_MODEL + "',");
sql.Append(" CAR_NAME = '" + newItem.CAR_NAME + "',");
sql.Append(" CAR_REMARK = '" + newItem.CAR_REMARK + "',");
sql.Append(" CAR_STATUS = '" + newItem.CAR_STATUS + "',");
sql.Append(" UPDATE_DATE = '" + DateTime.Now + "',");
sql.Append(" UPDATE_USER = '******'");
sql.Append(" WHERE CAR_CODE = '" + oldItem.CAR_CODE + "'");
sql.Append(" AND CAR_ENGINE = '" + oldItem.CAR_ENGINE + "'");
sql.Append(" AND CAR_MODEL = '" + oldItem.CAR_MODEL + "'");
sql.Append(" AND CAR_NAME = '" + oldItem.CAR_NAME + "'");
SqlCommand cmd = new SqlCommand(sql.ToString(), DBbase.con);
cmd.ExecuteNonQuery();
DBbase.DisConnect();
}
catch (Exception ex)
{
throw ex;
}
}
void SetCarStats()
{
carReferenced = GlobalGameData.currentInstance.GetCarInUse();
if (GlobalGameData.currentInstance.m_playerData_eventActive.GetSpecialEventType() == EventData.SpecialEvent.SoundSpeed)
{
turnRate = STAT_TURNRATE_BASE + 10 * STAT_TURNRATE_SCAL;
acceleration = STAT_ACCELERATION_BASE + 10 * STAT_ACCELERATION_SCAL;
maxFwdSpeed = STAT_MAXSPEED_BASE + 10 * STAT_MAXSPEED_SCAL;
maxBwdSpeed = -(maxFwdSpeed * 0.35f);
driftStrenght = STAT_DRIFTSTR_BASE + 10 * STAT_DRIFTSTR_SCAL;
maxDrift = STAT_MAXDRIFT_BASE + 10 * STAT_MAXDRIFT_SCAL;
driftSpeedConservation = STAT_DRIFTSPDCONS_BASE + (10) * STAT_DRIFTSPDCONS_SCAL;
driftStabilization = driftStrenght * 0.65f;
speedFalloffReductionFwd = STAT_SPDFALLOFF_BASE + carReferenced.GetAcceleration() * STAT_SPDFALLOFF_SCAL;
speedFalloffReductionBwd = speedFalloffReductionFwd * 2f;
carWeight = STAT_WEIGHT_BASE;
specialEventNoBrakes = true;
}
else
{
turnRate = STAT_TURNRATE_BASE + carReferenced.GetTurnRate() * STAT_TURNRATE_SCAL;
acceleration = STAT_ACCELERATION_BASE + carReferenced.GetAcceleration() * STAT_ACCELERATION_SCAL;
maxFwdSpeed = STAT_MAXSPEED_BASE + carReferenced.GetMaxSpeed() * STAT_MAXSPEED_SCAL;
maxBwdSpeed = -(maxFwdSpeed * 0.35f);
driftStrenght = STAT_DRIFTSTR_BASE + carReferenced.GetDriftStrenght() * STAT_DRIFTSTR_SCAL;
maxDrift = STAT_MAXDRIFT_BASE + carReferenced.GetMaxDriftDegree() * STAT_MAXDRIFT_SCAL;
driftSpeedConservation = STAT_DRIFTSPDCONS_BASE + (10 - carReferenced.GetCarWeight()) * STAT_DRIFTSPDCONS_SCAL;
driftStabilization = driftStrenght * 0.65f;
speedFalloffReductionFwd = STAT_SPDFALLOFF_BASE + carReferenced.GetAcceleration() * STAT_SPDFALLOFF_SCAL;
speedFalloffReductionBwd = speedFalloffReductionFwd * 2f;
carWeight = STAT_WEIGHT_BASE + STAT_WEIGHT_SCAL * carReferenced.GetCarWeight();
}
}
public async Task AddCar(CarData car)
{
await using var db = new CarsContext();
await db.Cars.AddAsync(car);
await db.SaveChangesAsync();
}
public LotsManagerController(ApplicationContext context, CarData carData, ILogger <LotsController> _logger, IBetPerository rep, ICarLotsRepository c)
{
db = context;
carLotsRepository = c;
betRep = rep;
logger = _logger;
}
public virtual void Setup(CarData car)
{
name = car.name;
travelClass = car.travelClass;
type = car.type;
fulfillments = car.fulfillments;
}
void Change()
{
if (selectedCar != null && selectedCar.entity)
{
Read();
if (selectedCar.type != type || selectedCar.bonusId != bonusId)
{
int xline, xpos;
selectedCar = Find(selectedCar.entity, out xline, out xpos);
spawnedCars[line].RemoveAt(xpos);
GameObject.Destroy(selectedCar.entity);
selectedCar = SpawnCar(speed, line, cursorLine.position.z, type, bonusId);
}
selectedCar.carspeed = speed;
selectedCar.dist = cursorLine.position.z;
Vector3 newpos = selectedCar.entity.transform.position;
newpos.z = selectedCar.dist;
selectedCar.entity.transform.position = newpos;
MoveCarCursor();
}
}
public PopupCar()
{
try
{
InitializeComponent();
if (DataCommon.Exists("CAR_EDIT"))
{
item = (CarData)DataCommon.Get("CAR_EDIT");
txtCarCode.Text = item.CAR_CODE;
txtCarName.Text = item.CAR_NAME;
txtCarModel.Text = item.CAR_MODEL;
txtCarEngine.Text = item.CAR_ENGINE;
txtCarRemark.Text = item.CAR_REMARK;
cbbStatus.SelectedIndex = item.CAR_STATUS == "A" ? 0 : 1;
}
//else
//{
// txtCarCode.IsEnabled = true;
//}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
public override void Setup(CarData carData)
{
base.Setup(carData);
HousingCarData car = (HousingCarData)carData;
MaximumNumberOfOccupants = car.maximumNumberOfOccupants;
}
private void ChartControl_OnMouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
{
NHitTestResult result = nChartControl1.HitTest(e.X, e.Y);
NWatermark watermark = result.Object as NWatermark;
if (watermark == null)
{
return;
}
CarData car = watermark.Tag as CarData;
if (car == null)
{
return;
}
m_ReviewLabel.Text = "Concept car from " + car.AuthorName;
NSeries series = (NSeries)nChartControl1.Charts[0].Series[0];
series.Values.Clear();
series.Values.AddRange(car.Values);
nChartControl1.Refresh();
}
public void Init(CarData carData, SteeringTypeIdentifier steeringType)
{
_carData = carData;
_steeringType = steeringType;
_leftTyre.Init(carData, _isRearAxle ? TyrePositionIdentifier.RL : TyrePositionIdentifier.FL);
_rightTyre.Init(carData, _isRearAxle ? TyrePositionIdentifier.RR : TyrePositionIdentifier.FR);
}
public void setCardData(CarData data)
{
if (carFullName != null)
{
carFullName.text = data.carFullName;
}
if (releaseYear != null)
{
releaseYear.text = data.releaseYear.ToString();
}
if (producerLogo != null)
{
producerLogo.texture = data.producerLogo;
}
if (carPlacement != null)
{
if (car != null)
{
Destroy(car);
}
car = Instantiate(data.car, carPlacement.transform);
_DisableCarScripts();
_SetDefaultCarTransform();
}
if (background != null)
{
background.color = data.background;
}
}
private void UpdateTrailer(float thetaOldCar, float D, Transform dragVehicle, GameObject trailer, float trailerAttachmentZOffset)
{
TrailerTest trailerData = trailer.transform.GetComponent <TrailerTest>();
//Move the trailer to the attachment point - Should we use old or new values????
Vector3 dragVehiclePos = dragVehicle.position;
float dragVehicleHeading = dragVehicle.rotation.eulerAngles.y * Mathf.Deg2Rad;
Vector3 attachmentPoint = CarData.GetLocalZPosition(dragVehiclePos, dragVehicleHeading, trailerAttachmentZOffset);
trailer.transform.position = attachmentPoint;
//Update rotation
float theta = trailer.transform.eulerAngles.y * Mathf.Deg2Rad;
//Distance to rear axle from connection point
float d = Mathf.Abs(trailerData.rearWheelZOffset);
float thetaNew = VehicleSimulationModels.CalculateNewTrailerHeading(theta, thetaOldCar, D, d);
//Update the new values
Vector3 newRotation = new Vector3(0f, thetaNew * Mathf.Rad2Deg, 0f);
trailer.transform.rotation = Quaternion.Euler(newRotation);
}
public void load()
{
CarData data = Tools.LoadCar();
MaxtorquevariableR = data.MaxtorquevariableR; //torque massimo variabile
MaxtorquevariableF = data.MaxtorquevariableF; //torque massimo variabile
MaxtorqueairF = data.MaxtorqueairF; //torque massimo per l'aria
MaxtorqueairR = data.MaxtorqueairR; //torque massimo per l'aria
Brakefront = data.Brakefront; //potenza freno anteriore
Brakerear = data.Brakerear; //potenza freno posteriore
torqueFdv = data.torqueFdv; //valore che divide il max torque per ottenere il valore di accelerazione
torqueRdv = data.torqueRdv; //valore che divide il max torque per ottenere il valore di accelerazione
rotation_powa = data.rotation_powa; //potenza di rotazione
fuel = data.fuel; //fuel di partenza
fuelvalue = data.fuelvalue;
maxfuel = data.maxfuel;
divisoreconsumo = data.divisoreconsumo; //determina il consumo del databurante rapportato alla potenza , insomma l'efficenza , più alto = più efficiente
cmass = data.cmass; //massa del centro di gravità
frequency_front = data.frequency_front;
frequency_back = data.frequency_back;
dampening_front = data.dampening_front;
dampening_back = data.dampening_back;
height_front = data.height_front;
height_back = data.height_back;
editValue();
Tools.saveCar(this);
}
private void checkForNewOvertakes(GameStateData previousGameState, GameStateData currentGameState)
{
if (currentGameState.SessionData.SessionPhase == SessionPhase.Green &&
currentGameState.SessionData.SessionType == SessionType.Race && currentGameState.SessionData.CompletedLaps > 0)
{
if (currentGameState.Now > lastPassCheck.Add(passCheckInterval))
{
lastPassCheck = currentGameState.Now;
if (currentGameState.SessionData.TimeDeltaFront > 0)
{
gapsAhead.Add(currentGameState.SessionData.TimeDeltaFront);
}
if (currentGameState.SessionData.TimeDeltaBehind > 0)
{
gapsBehind.Add(currentGameState.SessionData.TimeDeltaBehind);
}
string currentOpponentAheadKey = currentGameState.getOpponentKeyInFront(true);
string currentOpponentBehindKey = currentGameState.getOpponentKeyBehind(true);
// seems like belt and braces, but as Raceroom names aren't unique we need to double check a pass actually happened here:
if (frequencyOfOvertakingMessages > 0 && currentOpponentAheadKey != opponentAheadKey)
{
if (currentGameState.SessionData.CurrentLapIsValid && !currentGameState.PitData.InPitlane &&
currentOpponentBehindKey == opponentAheadKey && isPassMessageCandidate(gapsAhead, passCheckSamplesToCheck, minAverageGapForPassMessage))
{
OpponentData carWeJustPassed = currentGameState.OpponentData[currentOpponentBehindKey];
if (carWeJustPassed.CompletedLaps == currentGameState.SessionData.CompletedLaps &&
CarData.IsCarClassEqual(carWeJustPassed.CarClass, currentGameState.carClass))
{
timeWhenWeMadeAPass = currentGameState.Now;
opponentKeyForCarWeJustPassed = currentOpponentBehindKey;
lastOvertakeWasClean = true;
if (currentGameState.CarDamageData.LastImpactTime > 0 && (currentGameState.SessionData.SessionRunningTime - currentGameState.CarDamageData.LastImpactTime) < secondsToCheckForDamageOnPass)
{
lastOvertakeWasClean = false;
}
}
}
gapsAhead.Clear();
}
if (frequencyOfBeingOvertakenMessages > 0 && opponentBehindKey != currentOpponentBehindKey)
{
if (!currentGameState.PitData.InPitlane && currentOpponentAheadKey == opponentBehindKey && isPassMessageCandidate(gapsBehind, beingPassedCheckSamplesToCheck, minAverageGapForBeingPassedMessage))
{
// TODO: check if we need to do a pit check here - don't think so
OpponentData carThatJustPassedUs = currentGameState.OpponentData[currentOpponentAheadKey];
if (carThatJustPassedUs.CompletedLaps == currentGameState.SessionData.CompletedLaps &&
CarData.IsCarClassEqual(carThatJustPassedUs.CarClass, currentGameState.carClass))
{
timeWhenWeWerePassed = currentGameState.Now;
opponentKeyForCarThatJustPassedUs = currentOpponentAheadKey;
}
}
gapsBehind.Clear();
}
opponentAheadKey = currentOpponentAheadKey;
opponentBehindKey = currentOpponentBehindKey;
}
}
}
public List <SlotData> GetSlotDetailsWrtFloor(int slotFloor)
{
List <SlotData> slotDataList = null;
try
{
using (OracleConnection con = new OracleConnection(Connection.connectionString))
{
if (con.State == System.Data.ConnectionState.Closed)
{
con.Open();
}
string sql = "select ps.F_LEVEL_ID,ps.AISLE, ps.F_ROW,ps.SLOT_TYPE,ps.SLOT_STATUS,ps.VALUE,ps.MANUAL_BLOCK,ps.REHANDLE,"
+ " ps.PREV_SLOT_STATUS, LC.card_Id,LC.car_type,LC.IS_ROTATE"
+ " FROM L2_PROC_SNAPSHOT ps left join l2_customers lc on ps.value=lc.card_id and LC.IS_RETRIEVED=0 "
+ " where ps.F_LEVEL_ID= " + slotFloor + " and (ps.SLOT_TYPE>0 or ps.slot_type=-11)";
OracleCommand selectCommand = new OracleCommand(sql, con);
using (OracleDataReader dreader = selectCommand.ExecuteReader())
{
if (dreader.HasRows)
{
slotDataList = new List <SlotData>();
while (dreader.Read())
{
SlotData objSlotData = null;
objSlotData = new SlotData();
objSlotData.SlotFloor = slotFloor;
objSlotData.SlotAisle = int.Parse(Convert.ToString(dreader["AISLE"]));
objSlotData.SlotRow = int.Parse(Convert.ToString(dreader["F_ROW"]));
objSlotData.SlotType = int.Parse(Convert.ToString(dreader["SLOT_TYPE"]));
objSlotData.SlotStatus = int.Parse(Convert.ToString(dreader["SLOT_STATUS"]));
objSlotData.slotValue = Convert.ToString(dreader["VALUE"]);
objSlotData.Disable = int.Parse(Convert.ToString(dreader["MANUAL_BLOCK"])) == 1;
objSlotData.Rehandle = int.Parse(Convert.ToString(dreader["REHANDLE"])) == 1;
objSlotData.PrevSlotStatus = int.Parse(Convert.ToString(dreader["PREV_SLOT_STATUS"]));
if (!String.IsNullOrEmpty(Convert.ToString(dreader["card_Id"])))
{
CarData objCarData = null;
objCarData = new CarData();
objCarData.CardId = Convert.ToString(dreader["card_Id"]);
objCarData.IsRotated = int.Parse(Convert.ToString(dreader["IS_ROTATE"])) == 1;
objCarData.CarType = int.Parse(Convert.ToString(dreader["car_type"]));
objSlotData.ObjCarData = objCarData;
}
slotDataList.Add(objSlotData);
}
}
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
return(slotDataList);
}
//
// Display vehicle positions along a path
//
public static void DisplayVehicleAlongPath(List <Node> path, CarData carData, Car trailer)
{
if (path == null || path.Count == 0)
{
return;
}
//Debug.Log(path.Count);
for (int i = 0; i < path.Count; i++)
{
//if (i % 20 == 0)
//{
// continue;
//}
Node node = path[i];
//The car
Vector3 carCenter = carData.GetCenterPos(node.rearWheelPos, node.heading);
Rectangle carRect = CarData.GetCornerPositions(carCenter, node.heading, carData.carWidth, carData.CarLength);
//DrawRect(carRect, Color.white, 90f);
//Debug.Log(node.rearWheelPos);
//Cabin
Vector3 cabinCenterPos = carData.GetSemiCabinCenter(node.rearWheelPos, node.heading);
//DrawLine(carCenter, cabinCenterPos, Color.blue, 90f);
Rectangle cabinRect = CarData.GetCornerPositions(cabinCenterPos, node.heading, carData.carWidth, carData.cabinLength);
//DrawRect(cabinRect, Color.white, 90f);
//The trailer
if (trailer == null)
{
continue;
}
Vector3 trailerAttachmentPos = carData.GetTrailerAttachmentPoint(node.rearWheelPos, node.heading);
//Now we need the trailer's rear-wheel pos based on the new heading
CarData trailerData = trailer.carData;
Vector3 trailerRearWheelPos = trailerData.GetTrailerRearWheelPos(trailerAttachmentPos, node.TrailerHeadingInRadians);
//DrawLine(carCenter, trailerRearWheelPos, Color.blue, 90f);
Vector3 trailerCenter = trailerData.GetCenterPos(trailerRearWheelPos, node.TrailerHeadingInRadians);
Rectangle trailerRect = CarData.GetCornerPositions(trailerCenter, node.TrailerHeadingInRadians, trailerData.carWidth, trailerData.CarLength);
DrawRect(trailerRect, Color.red, 90f);
}
}
private void FormMain_Load(object sender, EventArgs e)
{
this.udpSender = new UdpSender();
this.udpReciever = new UdpReciever();
this.carData = new CarData(this.udpReciever);
showSettingsForm();
}
public void OnEnable()
{
selectedCar = null;
if (carManager)
{
Populate();
}
}
/*
* Description: Car provided will resume it's route if it is the front car stopped in the lane.
*/
public void ResumeCar(CarData car)
{
// Resume car only if it is the front-most stopped car.
if (car.IndexInLane == m_laneStopIndices[car.LaneIndex])
{
m_laneStopIndices[car.LaneIndex] = int.MaxValue;
}
}
public void SetCardData(CarData data)
{
if (data != null)
{
CarCard card = cardInstance.GetComponent <CarCard>();
card.setCardData(data);
}
}
public void SelectCar(CarData newSelection)
{
if (newSelection != null)
{
currentCar = newSelection;
onSelectionChange.Invoke(currentCar);
}
}
void Update() {
position = new Vector3 (transform.position.x, transform.position.y + 1, transform.position.z);
if (Physics.Raycast (position, -Vector3.up, out hit)) {
if (hit.transform.tag != "Track") {
print ("TrackDetection.Update(): you went off the track");
carId = GetComponentInParent<Engine> ().carId;
torque = GetComponentInParent<Engine> ().engineTorque;
List<CarData> cars = GameObject.Find ("Game Controller").GetComponent<GameController> ().cars;
thisCar = cars [carId - 1];
currentCheckpoint = thisCar.currentCheckpoint + 1;
checkpointPos = GameObject.Find ("Checkpoint " + currentCheckpoint).GetComponent<Transform> ().position;
newCurrentCheckpointPos = new Vector3 (checkpointPos.x, checkpointPos.y+1, checkpointPos.z);
transform.position = checkpointPos;
torque = 0;
}
}
}
private OvertakingAids getOvertakingAids(RaceRoomShared shared, CarData.CarClassEnum carClassEnum, int lapsCompleted, SessionType sessionType)
{
OvertakingAids overtakingAids = new OvertakingAids();
overtakingAids.DrsAvailable = shared.DrsAvailable == 1;
overtakingAids.DrsEngaged = shared.DrsEngaged == 1;
if (carClassEnum == CarData.CarClassEnum.DTM_2014)
{
overtakingAids.DrsEnabled = sessionType == SessionType.Race && lapsCompleted > 2;
overtakingAids.DrsRange = 2;
}
else if (carClassEnum == CarData.CarClassEnum.DTM_2015)
{
overtakingAids.DrsEnabled = sessionType == SessionType.Race && lapsCompleted > 3;
overtakingAids.DrsRange = 1;
}
overtakingAids.PushToPassActivationsRemaining = shared.push_to_pass.amount_left;
overtakingAids.PushToPassAvailable = shared.push_to_pass.available == 1;
overtakingAids.PushToPassEngaged = shared.push_to_pass.engaged == 1;
overtakingAids.PushToPassEngagedTimeLeft = shared.push_to_pass.engaged_time_left;
overtakingAids.PushToPassWaitTimeLeft = shared.push_to_pass.wait_time_left;
return overtakingAids;
}
public float[] getTimeAndSectorsForBestOpponentLapInWindow(int lapsToCheck, CarData.CarClassEnum carClassToCheck)
{
CarData.CarClassEnum defaultCarClass = CarData.getDefaultCarClass().carClassEnum;
float[] bestLapWithSectors = new float[] { -1, -1, -1, -1 };
foreach (KeyValuePair<Object, OpponentData> entry in OpponentData)
{
// if we don't know the opponent's car class, include him
if (carClassToCheck == defaultCarClass || entry.Value.CarClass.carClassEnum == defaultCarClass || entry.Value.CarClass.carClassEnum == carClassToCheck)
{
float[] thisOpponentsBest = entry.Value.getTimeAndSectorsForBestLapInWindow(lapsToCheck);
if (bestLapWithSectors[0] == -1 || (thisOpponentsBest[0] > 0 && thisOpponentsBest[0] < bestLapWithSectors[0]))
{
bestLapWithSectors = thisOpponentsBest;
}
}
}
// special case for practice and qual - if we're looking for all the laps in the session, we might want to use the data sent by the game
// because the play may have joined mid-session. In these cases there might be an historical lap (before the player joined) that's actually faster.
if (lapsToCheck == -1 && SessionData.SessionFastestLapTimeFromGamePlayerClass > 0 &&
(SessionData.PlayerLapTimeSessionBest == -1 || SessionData.PlayerLapTimeSessionBest > SessionData.SessionFastestLapTimeFromGamePlayerClass))
{
// the player isn't the fastest in his class. This means that the game-sent best lap data will be an opponent lap
if (bestLapWithSectors[0] == -1 || bestLapWithSectors[0] > SessionData.SessionFastestLapTimeFromGamePlayerClass)
{
// there's an historical lap which is quicker than all the data we currently hold. Due to limitations in the shared memory blocks,
// we never have sector times for this historical lap, so we have to remove them and disable sector deltas until a better lap is recorded
bestLapWithSectors[0] = SessionData.SessionFastestLapTimeFromGamePlayerClass;
bestLapWithSectors[1] = -1;
bestLapWithSectors[2] = -1;
bestLapWithSectors[3] = -1;
}
}
return bestLapWithSectors;
}
private void Fire_LS(object o)
{
try
{
GameData_LS package = new GameData_LS();
/** TYRE TEMPERATURES **/
try
{
if (Telemetry.m.Sim.Player.Tyre_Temperature_LF_Middle > 0)
{
package.TyreTemperature_LF = Convert.ToByte(Limits(Telemetry.m.Sim.Player.Tyre_Temperature_LF_Middle - 273.16, 0, 150));
package.TyreTemperature_RF = Convert.ToByte(Limits(Telemetry.m.Sim.Player.Tyre_Temperature_RF_Middle - 273.16, 0, 150));
package.TyreTemperature_LR = Convert.ToByte(Limits(Telemetry.m.Sim.Player.Tyre_Temperature_LR_Middle - 273.16, 0, 150));
package.TyreTemperature_RR = Convert.ToByte(Limits(Telemetry.m.Sim.Player.Tyre_Temperature_RR_Middle - 273.16, 0, 150));
}
}
catch (Exception ex)
{ }
/** TYRE & BRAKE WEAR **/
package.TyreWear_F = Convert.ToByte(200 * Limits(Telemetry.m.Sim.Drivers.Player.TyreWear_LF + Telemetry.m.Sim.Drivers.Player.TyreWear_RF, 0, 2) / 2.0);
package.TyreWear_R = Convert.ToByte(200 * Limits(Telemetry.m.Sim.Drivers.Player.TyreWear_LR + Telemetry.m.Sim.Drivers.Player.TyreWear_RR, 0, 2) / 2.0);
package.BrakeWear_F = 0;
package.BrakeWear_R = 0;
/** CURRENT FUEL INFO **/
package.Fuel_Litre = Convert.ToUInt16(Limits(Telemetry.m.Sim.Player.Fuel, 0, 150) * 10);
package.Fuel_Laps = 0;
/** DRIVING TIMES **/
package.Laptime_Last = Convert.ToSingle(Limits(Telemetry.m.Sim.Drivers.Player.LapTime_Last,0,1200));
package.Laptime_Best = Convert.ToSingle(Limits(Telemetry.m.Sim.Drivers.Player.LapTime_Best,0,1200));
switch (Telemetry.m.Sim.Drivers.Player.SectorsDriven % 3)
{
case 0:
package.Split_Sector = Telemetry.m.Sim.Drivers.Player.Sector_3_Last - Telemetry.m.Sim.Drivers.Player.Sector_3_Best;
break;
case 1:
package.Split_Sector = Telemetry.m.Sim.Drivers.Player.Sector_1_Last - Telemetry.m.Sim.Drivers.Player.Sector_1_Best;
break;
case 2:
package.Split_Sector = Telemetry.m.Sim.Drivers.Player.Sector_2_Last - Telemetry.m.Sim.Drivers.Player.Sector_2_Best;
break;
}
package.Split_Sector = Convert.ToSingle(Limits(package.Split_Sector, -2, 2));
package.Split_Lap = Telemetry.m.Sim.Drivers.Player.LapTime_Best - Telemetry.m.Sim.Drivers.Player.LapTime_Last;
package.Split_Lap = Convert.ToSingle(Limits(package.Split_Lap, -2, 2));
package.RaceTime = (float)Limits(Telemetry.m.Sim.Session.Time - 30, 0, 3600);
package.RaceLength = 3600;
SendPackage(DashboardPackages.PACK_GAMEDATA_LS, ByteMethods.ToBytes(package));
/*** Temporarely do cardata here as well ***/
CarData cardata = new CarData();
cardata.RPM_Max = Convert.ToUInt16(Limits(Telemetry.m.Sim.Player.Engine_RPM_Max_Live * rads_to_rpm,200,25000)-200);
cardata.RPM_Idle = Convert.ToUInt16(Limits(Telemetry.m.Sim.Player.Engine_RPM_Idle_Max * rads_to_rpm,0,7000));
//cardata.HP_Max = Convert.ToUInt16(EngineCurve.GetMaxHP());
cardata.Gears = (byte)Limits(Telemetry.m.Sim.Drivers.Player.Gears,0, 10);
cardata.Fuel_Max = (byte)Limits(Telemetry.m.Sim.Drivers.Player.Fuel_Max,0,100);
cardata.GearRatio0 = Convert.ToSingle(Limits(GetGearRatio_Pure(0),0,20));
cardata.GearRatio1 = Convert.ToSingle(Limits(GetGearRatio_Pure(1),0,20));
cardata.GearRatio2 = Convert.ToSingle(Limits(GetGearRatio_Pure(2),0,20));
cardata.GearRatio3 = Convert.ToSingle(Limits(GetGearRatio_Pure(3),0,20));
cardata.GearRatio4 = Convert.ToSingle(Limits(GetGearRatio_Pure(4),0,20));
cardata.GearRatio5 = Convert.ToSingle(Limits(GetGearRatio_Pure(5),0,20));
cardata.GearRatio6 = Convert.ToSingle(Limits(GetGearRatio_Pure(6),0,20));
cardata.GearRatio7 = Convert.ToSingle(Limits(GetGearRatio_Pure(7),0,20));
//if (Telemetry.m.Sim.Name == "GTR2") // messy bugfix
/*
{
cardata.GearRatio0 = 12.0f;
cardata.GearRatio1 = cardata.GearRatio0 * 0.85f;
cardata.GearRatio2 = cardata.GearRatio1 * 0.85f;
cardata.GearRatio3 = cardata.GearRatio2 * 0.85f;
cardata.GearRatio4 = cardata.GearRatio3 * 0.85f;
cardata.GearRatio5 = cardata.GearRatio4 * 0.85f;
cardata.GearRatio6 = cardata.GearRatio5 * 0.85f;
}
ShiftRpm r = new ShiftRpm();
* cardata.RPM_Shift0 = cardata.RPM_Max;
cardata.RPM_Shift1 = Convert.ToUInt16(r.Get(1, r.GetRatioBetween(1)));
cardata.RPM_Shift2 = Convert.ToUInt16(r.Get(1, r.GetRatioBetween(2)));
cardata.RPM_Shift3 = Convert.ToUInt16(r.Get(1, r.GetRatioBetween(3)));
cardata.RPM_Shift4 = Convert.ToUInt16(r.Get(1, r.GetRatioBetween(4)));
cardata.RPM_Shift5 = Convert.ToUInt16(r.Get(1, r.GetRatioBetween(5)));
cardata.RPM_Shift6 = Convert.ToUInt16(r.Get(1, r.GetRatioBetween(6)));*/
ShiftRpm r = new ShiftRpm();
cardata.RPM_Shift0 = cardata.RPM_Max;
cardata.RPM_Shift1 = (ushort)Limits(cardata.RPM_Max, 0, 25000);
cardata.RPM_Shift2 = (ushort)Limits(cardata.RPM_Max, 0, 25000);
cardata.RPM_Shift3 = (ushort)Limits(cardata.RPM_Max, 0, 25000);
cardata.RPM_Shift4 = (ushort)Limits(cardata.RPM_Max, 0, 25000);
cardata.RPM_Shift5 = (ushort)Limits(cardata.RPM_Max, 0, 25000);
cardata.RPM_Shift6 = (ushort)Limits(cardata.RPM_Max, 0, 25000);
cardata.RPM_Shift7 = (ushort)Limits(cardata.RPM_Max, 0, 25000);
SendPackage(DashboardPackages.PACK_CARDATA, ByteMethods.ToBytes(cardata));
// Send leds config..
//return;
string[] leds = System.IO.File.ReadAllLines("LEDs.csv");
byte[] bf = new byte[leds.Length * 9 + 1];
bf[0] = 0;
int i = 1;
int k = 0;
foreach (string led in leds)
{
string[] data = led.Split(",".ToCharArray());
bf[i] = (byte)(Convert.ToByte(data[4]));
bf[i + 1] = (byte)(Convert.ToByte(data[1]));
bf[i + 2] = (byte)(Convert.ToByte(data[2]));
bf[i + 3] = (byte)(Convert.ToByte(data[3]));
byte[] bf_tmp = BitConverter.GetBytes(0);
bf[i + 4] = bf_tmp[0];
bf[i + 5] = bf_tmp[1];
bf[i + 6] = 64;
bf[i + 7] = Convert.ToByte(k * 50 / 16);
bf[i + 8] = 255;
i += 9;
k++;
}
SendPackage(DashboardPackages.PACK_PREFS_SHIFTBAR, bf);
bf = new byte[leds.Length * 9 + 1];
bf[0] = 1;
i = 1;
k = 0;
foreach (string led in leds)
{
string[] data = led.Split(",".ToCharArray());
bf[i] = 0;
bf[i + 1] = 5;
bf[i + 2] = 0;
bf[i + 3] = 5;
byte[] bf_tmp = BitConverter.GetBytes(600);
bf[i + 4] = bf_tmp[0];
bf[i + 5] = bf_tmp[1];
bf[i + 6] = 50;
bf[i + 7] = Convert.ToByte(((k % 2 == 0) ? 50 : 0));
bf[i + 8] = 200;
i += 9;
k++;
}
SendPackage(DashboardPackages.PACK_PREFS_SHIFTBAR, bf);
}
catch (Exception ex)
{ }
return;
}
void Start()
{
StartRaceTime = 0f;
data = new CarData[Cars.Length];
for (int i = 0; i < Cars.Length; ++i)
{
data[i] = new CarData();
data[i].Tag = Cars[i].tag;
if (data[i].Tag == "PlayerCar")
{
PlayerCar = data[i];
}
CurrentLapGUIText.text = "1";
Lap1TimeGUIText.text = TimeToString(0);
Lap2TimeGUIText.text = "";
Lap3TimeGUIText.text = "";
}
WinnerPanel.SetActive(false);
for (int i = 0; i < WinnerNames.Length; ++i)
{
WinnerNames[i].text = "";
WinnerTimes[i].text = "";
}
PausePanel.SetActive(false);
RestartRaceMessage.SetActive(false);
}
public void InstantiateCars(int ind) {
Vector3 pos;
GameObject car;
numCars = 0;
if (ind == 0) {
numCars = 1;
} else if (ind == 1) {
numCars = 2;
} else {
numCars = 4;
}
distances = new List<float>();
for (int i = 0; i < numCars; ++i) {
pos = new Vector3((10.0f * i) + transform.position.x, transform.position.y, transform.position.z);
car = Instantiate(carPrefab, pos, transform.rotation) as GameObject;
car.transform.name = "Car " + (i + 1);
car.GetComponent<InputController>().SetCarId(i + 1);
car.GetComponent<Engine>().carId = i + 1;
Camera cam = car.transform.FindChild("mainCamera").GetComponent<Camera>();
CarData carData = new CarData(i + 1, i + 1);
cars.Add(carData);
carTransforms.Add(car.transform);
distances.Add(0.0f);
switch (numCars) {
case 2:
if (i == 0)
{
cam.rect = new Rect(new Vector2(0.0f, 0.5f), new Vector2(1.0f, 0.5f));
} else
{
cam.rect = new Rect(new Vector2(0.0f, 0.0f), new Vector2(1.0f, 0.5f));
}
break;
case 4:
if (i == 0)
{
cam.rect = new Rect(new Vector2(0.0f, 0.5f), new Vector2(0.5f, 0.5f));
} else if (i == 1)
{
cam.rect = new Rect(new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f));
} else if (i == 2)
{
cam.rect = new Rect(new Vector2(0.0f, 0.0f), new Vector2(0.5f, 0.5f));
} else
{
cam.rect = new Rect(new Vector2(0.5f, 0.0f), new Vector2(0.5f, 0.5f));
}
break;
default:
break;
}
}
if (addAICars) {
for (int i=0; i<numberRacers-numCars; ++i) {
//TODO: Instantiate AI cars
}
}
raceInitialized = true;
StartCoroutine("Countdown");
}
static CarData GetCarDataFromFile(string __name)
{
CarData _carData = new CarData();
try
{
#if UNITY_ANDROID && !UNITY_EDITOR
WWW _www = new WWW(m_DataPath + "/" + __name + ".json");
while (!_www.isDone)
{
continue;
}
if (_www.error != null)
Debug.Log(_www.error);
_carData = JsonMapper.ToObject<CarData>(_www.text);
#else
_carData = JsonMapper.ToObject<CarData>(File.ReadAllText(m_DataPath + "/" + __name + ".json"));
#endif
}
catch (System.Exception ex)
{
Debug.Log("错误：" + ex.Message + "/r/n" + ex.StackTrace);
return null;
}
return _carData;
}
/// <summary>
/// 获取指定车的数据
/// </summary>
/// <param name="__name"></param>
/// <returns></returns>
public static CarData GetCarDataByName(string __name)
{
CarData _carData = new CarData();
if (m_carsData.TryGetValue(__name, out _carData))
{
return _carData;
}
else
{
Debug.LogError("指定的车数据不存在：" + __name);
return null;
}
}
