private void SortCars()
{
for (int i = 1; i < racers.Count; i++)
{
for (int x = i; x > 0; x--)
{
// first sort by gates passed
if (racers[x].tracking.gatesPassed > racers[x - 1].tracking.gatesPassed)
{
BaseCar temp = racers[x];
racers[x] = racers[x - 1];
racers[x - 1] = temp;
}
// then sort by distance
else if (racers[x].tracking.gatesPassed == racers[x - 1].tracking.gatesPassed)
{
if (racers[x].tracking.sqrDistToGate < racers[x - 1].tracking.sqrDistToGate)
{
BaseCar temp = racers[x];
racers[x] = racers[x - 1];
racers[x - 1] = temp;
}
else
{
// in the correct place :)
break;
}
}
}
}
}
internal void ResetRace()
{
if (!NetworkCore.isServer)
{
return;
}
// setup a new race
currentRace = new Race(this);
currentRace.Init(0.4f, 5, 5, 20);
for (int i = 0; i < cars.Length; i++)
{
// find spawn point
SpawnArea area = spawnZone.GetSpawn(i);
BaseCar car = cars[i];
car.pDriver.isGhost = false;
car.pGhostControl.SetGhostMode(false);
car.Restart(area.position, area.rotation);
currentRace.AddRacer(car);
}
// notify any listeners of this event
if (RaceRestartEvent != null)
{
RaceRestartEvent();
}
}
public void REC_NewLocalPlayer(NetReader reader)
{
int playerNumber = reader.ReadInt();
NetworkID vehicleID = NetworkID.GetDataFromBytes(reader);
// create local player mapping
LocalPlayer newPlayer = new LocalPlayer();
newPlayer.playerNumber = playerNumber;
newPlayer.vehicleID = vehicleID;
Debug.Log(vehicleID);
// TODO assign the vehicle
NetObjectID id = NetworkManager.GetObjectForID(vehicleID);
Debug.Log(id);
BaseCar car = id.GetComponent <BaseCar>();
// assign our vehicle to follow
Debug.Log("Got local player info from server!");
localPlayers.Add(newPlayer);
Camera.main.GetComponent <RaceCamera>().SetCameraTarget(car.thisTransform);
HasClient = true;
}
void SV_CreateCar(int slot, PlayerType typ)
{
// find spawn point
SpawnArea area = spawnZone.GetSpawn(slot);
// create the player car
NetworkPrefab prefab = NetworkManager.FindNetworkPrefab("player_car");
GameObject racerObj = NetworkManager.singleton.NetworkInstantiate(prefab, area.position, area.rotation, false);
BaseCar car = racerObj.GetComponent <BaseCar>();
// get a player for this car
GamePlayer player = PlayerInputManager.MakePlayerForCar(car);
car.pDriver = player;
// create an entry for this racer
RaceEntry entry = new RaceEntry(car, slot, "Racer " + slot, typ);
car.entry = entry;
car.visuals.carNum = slot;
// update the visuals
car.ApplyVisuals();
cars[slot] = car;
}
internal static void CarKilled(BaseCar baseCar)
{
NetWriter writer = NetworkManager.StartNetworkMessage("fx_spawn", singleton.thisNetworkID);
writer.WriteVector3(baseCar.transform.position);
NetworkManager.SendMessageToAllClients(writer, NetworkCore.UnreliableMsg, false);
}
private void Awake()
{
entity = GetComponent <BaseCar>();
allowHeldItems = !ins.configData.ActiveItems.Disable;
disallowedItems = ins.configData.ActiveItems.BlackList;
}
public static PlayerInput ThinkForCar(BaseCar car)
{
if (car == null)
{
return(PlayerInput.None);
}
Vector3 carPos = car.thisTransform.position;
Vector3 carFwd = car.thisTransform.forward;
PlayerInput input = new PlayerInput();
Gateway targetGate = car.tracking.gate;
Vector3 targetPos = targetGate.GetClosestPoint(carPos);
Vector3 dirToTarget = targetPos - carPos;
float fwdDot = Vector3.Dot(dirToTarget, carFwd);
float rightDot = Vector3.SignedAngle(car.thisTransform.forward, dirToTarget, car.thisTransform.up);
input.steerInput = DoClamp01(rightDot, -15, 15);
input.driveInput = DoClamp01(fwdDot, -1, 1);
if (car.canFlip)
{
input.useInput = 1f;
}
else
{
input.useInput = 0f;
}
return(input);
}
// Use this for initialization
void Awake()
{
if (!wheelGraphic)
{
Debug.LogError("WHEEL WITH NO GRAPHICS!!");
return;
}
car = this.GetComponentInParent <BaseCar>();
if (!car)
{
Debug.LogError("WHEEL WITH NO CAR!!");
return;
}
thisTransform = this.transform;
// auto fill the cars wheel arrays
if (wheelType == WheelType.front)
{
car.AddFrontWheel(this);
}
else
{
car.AddRearWheel(this);
}
}
public RaceEntry(BaseCar car, int number, string name, PlayerType typ)
{
this.vehicle = car;
this.vehicleNumber = number;
this.racerName = name;
this.playerType = typ;
this.state = RacerState.OUT;
}
void CreateCar(int carID, int vehicleID, Vector3 spawnPos, Quaternion spawnRot)
{
GameObject newObj = Instantiate(cars [carID], spawnPos, spawnRot);
BaseCar carScript = newObj.GetComponent <BaseCar> ();
carScript.SetVehicleNumber(vehicleID);
carScript.InitVehicle();
}
public void ShouldReturnBaseCar()
{
ICar car = new BaseCar();
Assert.AreEqual(100, car.Drive());
Assert.AreEqual(100, car.Attack());
Assert.AreEqual(100, car.Defend());
}
public void ShouldReturnRaceCar()
{
var baseCar = new BaseCar();
var car = new RaceCar(baseCar);
Assert.Equal(140, car.Drive());
Assert.Equal(90, car.Attack());
Assert.Equal(90, car.Defend());
}
// Update is called once per frame
void Update()
{
if (Input.GetKeyUp(KeyCode.Return))
{
followCam.target = leaderCam.target;
BaseCar car = followCam.target.GetComponent <BaseCar>();
car.ChangeInputs("player");
}
}
void OnTriggerEnter(Collider other)
{
BaseCar car = other.transform.root.GetComponent <BaseCar>();
if (car != null)
{
car.RandomItem();
}
}
internal static GamePlayer MakePlayerForCar(BaseCar car)
{
Debug.Log("Making player for vehicle " + car.entry.vehicleNumber);
GamePlayer player = new GamePlayer(PlayerType.BOT);
player.car = car;
players.Add(player);
return(player);
}
public void ShouldReturnAttackCar()
{
var baseCar = new BaseCar();
var car = new AttackCar(baseCar);
Assert.AreEqual(90, car.Drive());
Assert.AreEqual(130, car.Attack());
Assert.AreEqual(90, car.Defend());
}
public void ShouldReturnArmoredCar()
{
var baseCar = new BaseCar();
var car = new ArmoredCar(baseCar);
Assert.AreEqual(80, car.Drive());
Assert.AreEqual(100, car.Attack());
Assert.AreEqual(140, car.Defend());
}
// Update is called once per frame
void SpawnAllRacers()
{
for (int i = 0; i < racers; i++)
{
GameObject racerObj = (GameObject)Instantiate(racerPrefab, spawns[i].position, spawns[i].rotation);
BaseCar car = racerObj.GetComponent <BaseCar>();
car.SetVehicleNumber(i);
racerObj.name = "Racer " + i;
}
}
void _SetCarForController(int controllerNum, BaseCar car)
{
for (int i = 0; i < localPlayerData.Length; i++)
{
if (localPlayerData [i].inputs.controllerIndex == controllerNum)
{
localPlayerData [i].targetCar = car;
localPlayerData [i].camera.SetCameraTarget(car.transform);
}
}
}
public static TestDrive SeedTestDrive(ApplicationDbContext dbContext, BaseCar baseCar)
{
var dbTestDrive = new TestDrive()
{
Car = baseCar
};
SeedTestDrive(dbContext, dbTestDrive);
return(dbTestDrive);
}
public void RacerOut(BaseCar racer)
{
EffectsManager.CarKilled(racer); // spawn an explosion
racer.pDriver.isGhost = true; // now make us into a ghost
racer.pGhostControl.SetGhostMode(true);
racer.BroadcastVisuals();
Utils.ExplosionForce(racer.GetPosition(), 5, 30, explosionForceLayers);
int pID = ItemManager.singleton.GetPrefabIDForName("mine");
ItemManager.singleton.SpawnNewTempNetObject(pID, racer.GetPosition(), Quaternion.identity);
}
public void BaseCar_AttackTest()
{
// Arrange
ICar car = new BaseCar();
var expected = 100;
// Action
var actual = car.Attack();
// Arrange
Assert.AreEqual(expected, actual);
}
private void Awake()
{
entity = GetComponent <BaseCar>();
if (entity.IsMounted())
{
entity.DismountAllPlayers();
}
CreatePassengerSeats();
CreateTrunk();
}
public void ShouldReturnFullyDecoratedRaceCar()
{
var baseCar = new BaseCar();
var armoredCar = new ArmoredCar(baseCar);
var armoredCar2 = new ArmoredCar(armoredCar);
var raceCar = new RaceCar(armoredCar2);
ICar car = new AttackCar(raceCar);
Assert.AreEqual(90, car.Drive());
Assert.AreEqual(120, car.Attack());
Assert.AreEqual(160, car.Defend());
}
private void Awake()
{
car = GetComponent <BaseCar>();
//car.enabled = false;
if (car.IsMounted())
{
car.DismountAllPlayers();
}
CreatePassengerSeats();
CreateTrunk();
}
private void CheckLapped()
{
if (State != RaceState.RACING || racers.Count == 0)
{
return;
}
// check if last place has swapped
if (lastCar != racers[racers.Count - 1])
{
nextKillTime = Time.time + KillDelay;
lastCar = racers[racers.Count - 1];
}
// check if timer has expired
else if (Time.time > nextKillTime)
{
nextKillTime = Time.time + KillDelay;
// kill.
KillRacer(racers[racers.Count - 1]);
racers.RemoveAt(racers.Count - 1);
return;
}
// find gates of leader
int topGates = racers[0].tracking.gatesPassed;
// backtrack up the list
for (int i = racers.Count - 1; i > 0; i--)
{
int gateDiff = topGates - racers[i].tracking.gatesPassed;
// kill if at least 1 gate ahead
if (gateDiff > nodeCount)
{
KillRacer(racers[i]);
racers.RemoveAt(i);
break;
}
else if (gateDiff == nodeCount)
{
// kill if the leader is closer to the next gate than we are
if (racers[0].tracking.sqrDistToGate < racers[i].tracking.sqrDistToGate)
{
KillRacer(racers[i]);
racers.RemoveAt(i);
break;
}
}
}
}
public static BaseCar Create(CarType cartype)
{
BaseCar car = null;
switch (cartype)
{
case CarType.Sport:
car = lamborginiFactory.Create();
break;
case CarType.Suv:
car = bmwFactory.Create();
break;
}
return(car);
}
private BaseEntity SpawnAtLocation(Vector3 position, Quaternion rotation = default(Quaternion), bool enableSaving = false)
{
BaseCar entity = (BaseCar)GameManager.server.CreateEntity(carPrefab, position + Vector3.up, rotation);
entity.enableSaving = enableSaving;
entity.Spawn();
CarController controller = entity.gameObject.AddComponent <CarController>();
if (enableSaving)
{
saveableCars.Add(controller);
SaveData();
}
return(entity);
}
public void FixedSimulate(BaseCar Car)
{
RaycastHit hit;
int layerMask = 1 << 9;
if (Physics.Raycast(transform.position, -transform.up, out hit, SuspensionLength, layerMask))
{
HitPosition = hit.point;
LastLength = CurrentLength;
CurrentLength = (SuspensionLength - hit.distance) * (SuspensionLength - hit.distance);
float springVelocity = (CurrentLength - LastLength) / Time.fixedDeltaTime;
float springForce = SpringConstant * CurrentLength;
float damperForce = DamperConstant * springVelocity;
Car.Body.AddForceAtPosition(transform.up * (springForce + damperForce), transform.position);
}
}
public static void Execute()
{
BaseCar _carFerrai = new Ferrari("Enzo 2012")
{
precio = 15000000
};
BaseCar _carMazda = new Mazda("M3 2012")
{
precio = 10000000
};
BaseCar _car1 = _carFerrai.Clone();
_car1.Modelo = "Enzo 2015";
_car1.SetCaracteristicas(true, false);
BaseCar _car2 = _carMazda.Clone();
_car2.Modelo = "M6 2016";
_car2.precio = 13000000;
List <BaseCar> _ListCars = new List <BaseCar>();
int _cont = 1;
_ListCars.AddRange(new BaseCar[] { _car1, _carFerrai });
foreach (BaseCar car in _ListCars)
{
Console.WriteLine($"********** Carro #{_cont} **********");
Console.WriteLine($"Modelo: {car.Modelo}");
Console.WriteLine($"Precio: {car.precio}");
Console.WriteLine($"Es Automatico: {car._Caracteristicas.Automatico.ToString()}");
Console.WriteLine($"Tiene GPS: {car._Caracteristicas.Gps.ToString()}");
Console.WriteLine("");
_cont++;
}
}
