void OnTriggerEnter(Collider col)
{
// simulates click on a car
if (col.gameObject.CompareTag(Constants.Tag.TagVehicle))
{
gameObject.SetActive(false);
VehicleController vehicle = col.gameObject.GetComponent <VehicleController>();
bool isVehicleOnCurrentRoad = gameManager.speedLimitController.IsVehicleOnCurrentRoad(col.gameObject.transform.position.z);
if (isVehicleOnCurrentRoad)
{
if (vehicle.GetCurrentSpeed() > (float)gameManager.speedLimitController.currentRoadSpeed)
{
vehicle.SetCurrentSpeed(gameManager.speedLimitController.currentRoadSpeed);
gameManager.scoreController.AddScoreVehicleHit();
//Debug.Log("WIN POINTS because vehicle speed = " + vehicle.GetCurrentSpeed() + " and road is " + 0 + gameManager.speedLimitController.currentRoadSpeed);
}
else
{
gameManager.scoreController.SubScoreVehicleHit();
//Debug.Log("LOSE POINTS because vehicle speed = " + vehicle.GetCurrentSpeed() + " and road is " + 0 + gameManager.speedLimitController.currentRoadSpeed);
}
}
}
}
public override void Run()
{
IVehicleController controller = new VehicleController(
new VehicleWindow(),
new NHibernateVehicleDao()
);
}
public async Task CanCreateVehicleTestAsync()
{
//Arrange
TestApplicationDbContext tdb = new TestApplicationDbContext();
Vehicle vehicleToBeCreated = new Vehicle
{
Title = "Nissan Micra",
Price = 1250,
CubicCapicity = CC.cc1000,
FuelType = Fuel.Petrol
};
//creating a controller
VehicleController controller = new VehicleController(tdb);
//Act
//call controller searchIndexMethod
var result = await controller.Create(vehicleToBeCreated);
//var result = viewResult.ViewData.Model as IEnumerable<VehicleModel>;
//Assert
//we are checking that a view called Index is returned
Assert.IsInstanceOfType(result, typeof(RedirectToRouteResult));
//view Result for the cannot create
}
/**
* This method simulates traffic spawning at the given in-game time.
*/
public void SimulateAtTime(float inGameTime)
{
// Calculate estimated relative traffic volume by averaging the relative traffic volume throughout the hour
float lbRelativeTrafficVolume = CalculateRelativeTrafficVolumeAtTime(Mathf.FloorToInt(inGameTime));
float ubRelativeTrafficVolume = CalculateRelativeTrafficVolumeAtTime(Mathf.RoundToInt(inGameTime + 0.5f));
float relativeTrafficVolume = (lbRelativeTrafficVolume + ubRelativeTrafficVolume) / 2.0f;
foreach (KeyValuePair <EntryRoad, List <Traffic> > trafficStartingAt in trafficsStartingAt)
{
if (inGameTime >= nextSpawnTimes[trafficStartingAt.Key])
{
Path path = nextSpawnTraffics[trafficStartingAt.Key].Value.GetRandomPath();
LinkedListNode <Road> firstRoadNode = path.Roads.First;
VehicleController vehicle = Instantiate(
vehicleFactory.GetRandomVehicle(),
firstRoadNode.Value.StartGrid.transform.position,
firstRoadNode.Value.transform.rotation);
vehicle.Initialize(firstRoadNode);
// Add simulation manager as the speed observer
vehicle.AddObserver(SiteManager.Instance.simulationManager);
// Increment spawn time and move traffic iterator
nextSpawnTimes[trafficStartingAt.Key] += 1.0f
/ (relativeTrafficVolume * trafficStartingAt.Value.Sum(i => i.TrafficVolume));
nextSpawnTraffics[trafficStartingAt.Key] = nextSpawnTraffics[trafficStartingAt.Key].Next;
}
}
}
public static void Init()
{
GroupController.LoadGroups();
VehicleController.LoadVehicles();
PropertyController.LoadProperties();
JobController.LoadJobs();
}
void Awake()
{
lastAutoUpdate = Time.time;
controller = GetComponent <VehicleController>();
input = GetComponent <CarInputController>();
input[InputEvent.ENABLE_LEFT_TURN_SIGNAL].Press += controller.EnableLeftTurnSignal;
input[InputEvent.ENABLE_RIGHT_TURN_SIGNAL].Press += controller.EnableRightTurnSignal;
input[InputEvent.GEARBOX_SHIFT_DOWN].Press += controller.GearboxShiftDown;
input[InputEvent.GEARBOX_SHIFT_UP].Press += controller.GearboxShiftUp;
input[InputEvent.TOGGLE_SHIFT].Press += controller.ToggleShift;
input[InputEvent.ENABLE_HANDBRAKE].Press += controller.ToggleHandBrake;
input[InputEvent.HEADLIGHT_MODE_CHANGE].Press += controller.ChangeHeadlightMode;
input[InputEvent.TOGGLE_IGNITION].Press += controller.ToggleIgnition;
input[InputEvent.TOGGLE_CRUISE_MODE].Press += controller.ToggleCruiseMode;
input[InputEvent.SET_WIPER_OFF].Release += controller.SetWindshiledWiperLevelOff;
input[InputEvent.SET_WIPER_AUTO].Release += controller.SetWindshiledWiperLevelAuto;
input[InputEvent.SET_WIPER_LOW].Release += controller.SetWindshiledWiperLevelLow;
input[InputEvent.SET_WIPER_MID].Release += controller.SetWindshiledWiperLevelMid;
input[InputEvent.SET_WIPER_HIGH].Release += controller.SetWindshiledWiperLevelHigh;
input[InputEvent.TOGGLE_WIPER].Press += controller.IncrementWiperState;
// CES
// ???
//input[InputEvent.ACCEL].Release += controller.ToggleBrakeLightsOff;
//input[InputEvent.BRAKE].Release += controller.ToggleBrakeLightsOn;
}
public void GetAllVehicles_ReturnsListOfVehicles()
{
var mockService = new Mock <IVehicleService>();
mockService
.Setup(service => service.GetAllVehicles())
.Returns(
new List <ResponseVehicle>
{
new ResponseVehicle {
Vin = "MyVin1", RegistrationNumber = "MyReg1", CompanyId = 1, LastCommunicated = 123456
},
new ResponseVehicle {
Vin = "MyVin2", RegistrationNumber = "MyReg2", CompanyId = 2, LastCommunicated = 567890
}
});
var mockLogger = new Mock <ILogger <CompanyController> >();
var controller = new VehicleController(mockService.Object, mockLogger.Object);
var result = controller.Vehicles();
Assert.AreEqual(2, result.Count);
Assert.AreEqual("MyVin1", result[0].Vin);
Assert.AreEqual("MyReg1", result[0].RegistrationNumber);
Assert.AreEqual(1, result[0].CompanyId);
}
public virtual void Validate(VehicleController vc)
{
if (inertia < 0.01f)
{
inertia = 0.01f;
Debug.LogWarning($"{name}: Inertia must be larger than 0.01f. Setting to 0.01f.");
}
}
public void RpcQuitVehicle()
{
state = PlayerStates.Normal;
currentVehicle = null;
transform.position += Vector3.up;
transform.SetParent(null);
GetComponent <CharacterController>().detectCollisions = true;
}
private void Start()
{
NextSend = Time.time + 1.0f / Frequency;
controller = GetComponent <VehicleController>();
input_controller = GetComponent <VehicleInputController>();
gps = GetComponentInChildren <GpsDevice>();
mainRigidbody = GetComponent <Rigidbody>();
}
private void RespawnWithPrefab()
{
VehicleFactory.Params param = new VehicleFactory.Params(m_waypoints [m_currWaypointIndex].position, m_waypoints [m_currWaypointIndex].rotation);
VehicleController controller = m_factory.Create(param);
controller.SetWaypoint(m_currWaypointIndex);
Destroy();
}
// Use this for initialization
void Start()
{
remoteEndPoint = new IPEndPoint(IPAddress.Parse(IP), port);
client = new UdpClient();
tempo = 0;
vehicleController = gameObject.GetComponent <VehicleController>();
_pidPars = Resources.Load <PIDPars>("PIDPars_steeringWheel");
}
void Start()
{
linesUtilsAlt.LineRend = linesUtilsAlt.CreateLineRenderer(ref linesUtilsAlt.lineRendererEmpty, "TrafLineRenderer", 1.0f, new Color32(0x4C, 0x8B, 0xDD, 0xFF), mat, () => linesUtilsAlt.InitGlowTexture());
pathEnhanced = GameObject.Find("SplinePCH(Clone)");
vc = FindObjectOfType(typeof(VehicleController)) as VehicleController;
StartCoroutine(InitNavigationLine());
StartCoroutine(NavigationLine(0.25f));
}
private void Start()
{
InvokeRepeating("sampleEmotion", 1.0f, 1.0f);
//InvokeRepeating("finalize", 8.0f, 8.0f);
emotionContainer = new EmotionContainer();
vehicleController = GameObject.Find("Vehicle").GetComponent <VehicleController>();
timeScript = GameObject.Find("TimerText").GetComponent <TimerScript>();
}
void Awake()
{
// Retrieves the desired components
_transform = transform;
_vehicleTransform = _transform.parent.GetComponent <Transform>();
_vehicleController = _vehicleTransform.GetComponent <VehicleController>();
_cameraTransfrom = GetComponentInChildren <Camera>().transform;
}
public VehicleQuoteUnitTest()
{
_controller = new VehicleController();
var path = AppDomain.CurrentDomain.BaseDirectory.ToString();
path += @"/../../../VehicleQuote/App_Data";
_controller.Path = path;
}
public void SearchVehicles_WrongStatus_NoResults()
{
VehicleController controller = new VehicleController(vehicleService, unitOfWork);
var vehiclesList = controller.SearchVehicles(1, 1);
Assert.AreEqual(vehiclesList.Count(), 0);
}
void Awake()
{
rb = GetComponent <Rigidbody>();
vehicleController = GetComponent <VehicleController>();
dataStream = DataStreamServer.Instance;
lastYaw = transform.localRotation.eulerAngles.y;
lastRoll = transform.localRotation.eulerAngles.z;
}
public void SearchVehicles_WrongCustomer_NoResults()
{
VehicleController controller = new VehicleController(vehiclesManager);
var vehiclesList = controller.SearchVehicles(5, 1);
Assert.AreEqual(vehiclesList.Count(), 0);
}
public void GetAllVehicles_ShouldReturnAllVehicles()
{
var testVehicles = GetAllVehicles();
var controller = new VehicleController(new MockVehiclePersistent());
var result = controller.Get() as List <Vehicle>;
Assert.AreEqual(testVehicles.Count, result.Count);
}
public void Initialize(VehicleController vc, WheelComponent wheelComponent)
{
_vc = vc;
_wheelComponent = wheelComponent;
if (!vc.groundDetection.IsEnabled || vc.groundDetection.groundDetectionPreset == null)
{
return;
}
// Initialize particles
if (vc.groundDetection.groundDetectionPreset.particlePrefab != null)
{
particlePrefab = Object.Instantiate(
vc.groundDetection.groundDetectionPreset.particlePrefab,
wheelComponent.ControllerTransform,
true);
particlePrefab.transform.position = wheelComponent.wheelController.wheel.worldPosition
- wheelComponent.wheelController.cachedTransform.up * (wheelComponent.wheelController.radius * 0.5f);
particlePS = particlePrefab.GetComponent <ParticleSystem>();
particlePS.name = "SurfaceParticles";
ParticleSystem.ShapeModule shape = particlePS.shape;
shape.radius = wheelComponent.Width * 1.5f;
_shapeModule = particlePS.shape;
_shapeModule.radius = wheelComponent.Width;
}
else
{
Debug.LogWarning("Smoke Prefab is null, wheel slip will not produce particles.");
}
// Initialize chunks
if (vc.groundDetection.groundDetectionPreset.chunkPrefab != null)
{
chunkPrefab = Object.Instantiate(
vc.groundDetection.groundDetectionPreset.chunkPrefab,
wheelComponent.ControllerTransform,
true);
chunkPrefab.transform.position = wheelComponent.wheelController.wheel.worldPosition
- wheelComponent.wheelController.cachedTransform.up *
wheelComponent.wheelController.radius
- wheelComponent.wheelController.cachedTransform.forward *
(wheelComponent.wheelController.radius * 0.7f);
chunkPS = chunkPrefab.GetComponent <ParticleSystem>();
chunkPS.name = "SurfaceChunks";
_shapeModule = chunkPS.shape;
_shapeModule.radius = wheelComponent.Width;
}
else
{
Debug.LogWarning("Dust Prefab is null, there will be no surface dust.");
}
_initialized = true;
}
public override void Validate(VehicleController vc)
{
base.Validate(vc);
Debug.Assert(stallRPM < idleRPM, "Engine stall RPM is higher than idle RPM. Vehicle will always stall.");
Debug.Assert(powerCurve.keys.Length > 1, "Engine power curve is not set up. Engine will not run.");
Debug.Assert(!string.IsNullOrEmpty(outputASelector.name),
"Engine is not connected to anything. Go to Powertrain > Engine and set the output.");
}
/// <summary>
/// Changes vehicle to a vehicle with the requested name if there is such a vehicle.
/// </summary>
public void ChangeVehicle(VehicleController vc)
{
int vehicleIndex = vehicles.IndexOf(vc);
if (vehicleIndex >= 0)
{
ChangeVehicle(vehicleIndex);
}
}
/// <summary>
/// Start this instance.
/// </summary>
void Start()
{
guiReplay = GameObject.FindGameObjectWithTag ("GUI").GetComponent<GuiReplay>();
scoreController = Gameplay.World.WorldSpawnManager.Instance.GetComponent<ScoreController>();
player = GameObject.FindGameObjectWithTag ("Player");
vehicleSound = player.GetComponent<VehicleSound> ();
vehicleController = player.GetComponent<VehicleController>();
}
public void GetFordModels()
{
var vehicleController = new VehicleController();
IEnumerable <string> modelResult = vehicleController.Get("Ford");
IEnumerable <string> emptyModelResult = vehicleController.Get("Toyota");
Assert.IsTrue(modelResult.Count() == 2);
Assert.IsTrue(emptyModelResult.Count() == 0);
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
activeQuoteViewModel = e.Parameter as ActiveQuoteViewModel;
vc = new VehicleController(activeQuoteViewModel.Drivers, activeQuoteViewModel.q.Id,
activeQuoteViewModel.Drivers.First().ID);
this.DataContext = vc.VehicleViewModel;
vehicleViewModel = vc.VehicleViewModel;
activeQuoteViewModel.Vehicles.Add(vehicleViewModel);
}
static void Main(string[] args)
{
try
{
VehicleController controller = new VehicleController();
//"Volvo", "Saab", "Honda" or "Suzuki".
VehicleMake make = new VehicleMake();
make.Description = "Volvo";
VehicleMake make1 = new VehicleMake();
make1.Description = "Saab";
VehicleMake make2 = new VehicleMake();
make2.Description = "Honda";
VehicleMake make3 = new VehicleMake();
make3.Description = "Suzuki";
VehicleType type1 = new VehicleType();
type1.Description = "Car";
VehicleType type2 = new VehicleType();
type2.Description = "Bike";
Vehicle vehicle = new Vehicle();
vehicle.Description = "My New Car";
vehicle.RegistrationId = "ABC-134";
vehicle.MakeId = 1;
vehicle.TypeId = 1;
Vehicle vehicle1 = new Vehicle();
vehicle1.Description = "My Honda Bike";
vehicle1.RegistrationId = "DEF-8853";
vehicle1.MakeId = 3;
vehicle1.TypeId = 2;
controller.CreateOrUpdateVehicleMake(make);
controller.CreateOrUpdateVehicleMake(make1);
controller.CreateOrUpdateVehicleMake(make2);
controller.CreateOrUpdateVehicleMake(make3);
controller.CreateOrUpdateVehicleType(type1);
controller.CreateOrUpdateVehicleType(type2);
controller.CreateOrUpdateVehicle(vehicle);
controller.CreateOrUpdateVehicle(vehicle1);
Console.WriteLine("Information Saved Successfully");
}
catch (Exception ex)
{
Console.WriteLine("Error: " + ex.Message);
}
}
public void AddDataPoint(VehicleController vehicle, float speed)
{
if (!observedAverageSpeeds.ContainsKey(vehicle))
{
observedAverageSpeeds.Add(vehicle, new Averager());
}
observedAverageSpeeds[vehicle].AddDataPoint(speed);
}
public override void Awake(VehicleController vc)
{
base.Awake(vc);
foreach (Bone bone in bones)
{
bone.Initialize();
}
}
void Start()
{
if (vehicleCtrl == null)
{
vehicleCtrl = GetComponentInParent <VehicleController>();
}
CheckTimeOfDayEvents();
}
public override void SetDefaults(VehicleController vc)
{
base.SetDefaults(vc);
baseVolume = 0.5f;
basePitch = 1.2f;
// Clip set throught surface map system
}
// Use this for initialization
void Start () {
GameObject aiVehicleObj = GameObject.Find("VehicleAI");
VehicleController aiVehicle = (VehicleController) aiVehicleObj.GetComponent("VehicleController");
aiVehicle.ResetUserControl();
aiVehicle.gameObject.SetActive(false);
ai = (VehicleController)Instantiate(aiVehicle, new Vector3(-10, 0, -10), new Quaternion(0, 0, 0, 0));
ai.gameObject.SetActive(true);
//ai.transform.Translate(new Vector3(10, 10, 10));
ai.ResetUserControl();
}
// Update is called once per frame
void Update()
{
Ray ray = new Ray(transform.position, transform.forward);
if(Physics.Raycast(ray, out hit, 10)){
Debug.DrawLine (ray.origin, hit.point);
hitVehicleController = hit.collider.gameObject.GetComponent<VehicleController>();
if(hitVehicleController.vehType == VehicleType.Bus){
// Debug.Log("taxi stopping here");
//rotateTheTaxi = true;
hitVehicleController.busStop = true;
}
}
}
private bool checkFaceToFaceVehicles(VehicleController vehCtrl_1, VehicleController vehCtrl_2)
{
if(vehCtrl_1._direction == StreetDirection.Up && vehCtrl_2._direction == StreetDirection.Down){
if(vehCtrl_1.gameObject.transform.position.z < vehCtrl_2.gameObject.transform.position.z)
return true;
}
if(vehCtrl_1._direction == StreetDirection.Right && vehCtrl_2._direction == StreetDirection.Left){
if(vehCtrl_1.gameObject.transform.position.x < vehCtrl_2.gameObject.transform.position.x)
return true;
}
if(vehCtrl_1._direction == StreetDirection.Up && vehCtrl_2._direction == StreetDirection.Left){
if( vehCtrl_1.gameObject.transform.position.z < vehCtrl_2.gameObject.transform.position.z &&
vehCtrl_1.gameObject.transform.position.x < vehCtrl_2.gameObject.transform.position.x){
return true;
}
}
if(vehCtrl_1._direction == StreetDirection.Up && vehCtrl_2._direction == StreetDirection.Right){
if( vehCtrl_1.gameObject.transform.position.z < vehCtrl_2.gameObject.transform.position.z &&
vehCtrl_1.gameObject.transform.position.x > vehCtrl_2.gameObject.transform.position.x)
return true;
}
if(vehCtrl_1._direction == StreetDirection.Down && vehCtrl_2._direction == StreetDirection.Left){
if( vehCtrl_1.gameObject.transform.position.z > vehCtrl_2.gameObject.transform.position.z &&
vehCtrl_1.gameObject.transform.position.x < vehCtrl_2.gameObject.transform.position.x)
return true;
}
if(vehCtrl_1._direction == StreetDirection.Down && vehCtrl_2._direction == StreetDirection.Right){
if( vehCtrl_1.gameObject.transform.position.z > vehCtrl_2.gameObject.transform.position.z &&
vehCtrl_1.gameObject.transform.position.x > vehCtrl_2.gameObject.transform.position.x)
return true;
}
return false;
}
// Update is called once per frame
void Update()
{
if(! done){
Ray ray = new Ray(transform.position, transform.forward);
if(Physics.Raycast(ray, out hit, 12)){
Debug.DrawLine (ray.origin, hit.point);
hitVehicleController = hit.collider.gameObject.GetComponent<VehicleController>();
if(hitVehicleController.vehType == VehicleType.Taxi){
Debug.Log("taxi stopping 3 ");
// hitVehicleController.taxiStop3 = true;
done = true;
}
}
}
/*
if(rotateTheTaxi && hit.collider!= null){
if(hitVehicleController.speed > 0){
hitVehicleController.speed -= 15 ;
GameObject.FindGameObjectWithTag("taxiStop").GetComponent<StopperArea>().rotateTheTaxi = false;
hit.collider.gameObject.transform.Rotate(-1*Vector3.up* 80 * Time.deltaTime, Space.Self);
Debug.Log("rotate bel3aksss");
//transform.RotateAround(rotateAroundPosition, Vector3.up, worldRotateSpeed * Time.deltaTime);
if(-1*hit.collider.gameObject.transform.forward.z >=0){
Debug.Log("what the hell " + -1*hit.collider.gameObject.transform.forward.z);
hitVehicleController.speed =0;
rotateTheTaxi =false;
hitVehicleController.haveToReduceMySpeed = true;
//hit.collider.gameObject.transform.forward = -1*Vector3.right;
}
}
else{
hitVehicleController.SetStopTimeForTaxi();
}
hitVehicleController.haveToReduceMySpeed = true;
}
*/
}
public static bool HasFinishedRotation(Vector3 transformForward, bool rotateNow, StreetDirection direction, StreetDirection nextDirection, VehicleController vehScript)
{
//Debug.Log("direc is >> " + direction);
if(direction != nextDirection){
// Debug.Log("transformForward ... " + -1*transformForward.x );
if(direction == StreetDirection.Left && -1*transformForward.x > -0.01 && rotateNow && nextDirection == StreetDirection.Up){
vehScript.gameObject.transform.forward = -1*Vector3.forward;
vehScript.speed = vehScript.myVehicle.Speed;
return true;
}
if(direction == StreetDirection.Right && -1*transformForward.x < 0.01 && rotateNow && nextDirection == StreetDirection.Up){
vehScript.gameObject.transform.forward = -1*Vector3.forward;
vehScript.speed = vehScript.myVehicle.Speed;
// Debug.Log("safwattttttttttttt");
return true;
}
if(direction == StreetDirection.Up && -1*transformForward.z < 0.01 && rotateNow && nextDirection == StreetDirection.Left){
vehScript.gameObject.transform.forward = Vector3.right;
vehScript.speed = vehScript.myVehicle.Speed;
return true;
}
if(direction == StreetDirection.Down && -1*transformForward.z > -0.01 && rotateNow && nextDirection == StreetDirection.Left){
vehScript.gameObject.transform.forward = Vector3.right;
vehScript.speed = vehScript.myVehicle.Speed;
return true;
}
///////////////////////////////////////////////////
if(direction == StreetDirection.Left && -1*transformForward.x > -0.01 && rotateNow && nextDirection == StreetDirection.Down){
vehScript.gameObject.transform.forward = Vector3.forward;
vehScript.speed = vehScript.myVehicle.Speed;
return true;
}
if(direction == StreetDirection.Right && -1*transformForward.x < 0.01 && rotateNow && nextDirection == StreetDirection.Down){
vehScript.gameObject.transform.forward = Vector3.forward;
vehScript.speed = vehScript.myVehicle.Speed;
return true;
}
if(direction == StreetDirection.Down && -1*transformForward.z > -0.01 && rotateNow && nextDirection == StreetDirection.Right){
vehScript.gameObject.transform.forward = -1*Vector3.right;
vehScript.speed = vehScript.myVehicle.Speed;
return true;
}
if(direction == StreetDirection.Up && -1*transformForward.z < 0.01 && rotateNow && nextDirection == StreetDirection.Right){
vehScript.gameObject.transform.forward = -1*Vector3.right;
vehScript.speed = vehScript.myVehicle.Speed;
return true;
}
else
return false;
}
return true;
}
public static bool HaveToAccelerate(Transform transform, StreetDirection direction,Vector3 endPosition, Street street, VehicleController vehScript)
{
float rate = 2;
//Debug.Log("da5al hena ");
if(CompareTwoPositionsWRTDirections(direction, transform.position, endPosition, -15)){
// if(!vehScript._light.Stopped && vehScript.speed > 0){
// vehScript.speed -= rate ;
// }
// Debug.Log("hello I'm here");
if(!vehScript._light.Stopped)
vehScript.speed = 18 ;
vehScript.haveToReduceMySpeed = true;
return true;
}
return false;
}
public static bool IsLeavingTheStreet_Rotate(GameObject [] corners, Transform transform, StreetDirection direction,Vector3 endPosition, Street street, StreetDirection nextDirection, VehicleController vehScript)
{
Vector3 obPos = transform.position;
if(CompareTwoPositionsWRTDirections(direction, transform.position, endPosition, -5)){
if(vehScript.rotateAroundPosition == Vector3.zero){
// vehScript.speed = 10;
// vehScript.haveToReduceMySpeed = true;
vehScript.rotateAroundPosition = MathsCalculatios.GetNearestCorner(corners, transform.position);
// Debug.Log(vehScript.rotateAroundPosition);
// Debug.Log("the center " + vehScript.rotateAroundPosition);
}
return true;
}
else {
vehScript.rotateAroundPosition = Vector3.zero;
}
return false;
}
private void initAndConnect(string ip, short port, string nickname)
{
currentIP = ip;
GTA.Native.Function.Call("DISABLE_PAUSE_MENU", 1);
GTA.Native.Function.Call("SET_FILTER_MENU_ON", 1);
BroadcastingPaused = true;
playerNames = new Dictionary<uint, string>();
playerModels = new Dictionary<uint, string>();
isCurrentlyDead = false;
actionQueue = new Queue<Action>();
instance = this;
jsEngine = new JavaScriptEngine();
CurrentVirtualWorld = 0;
cameraController = new CameraController(this);
debugDraw = new ClientTextView(new System.Drawing.PointF(10, 400), "", new GTA.Font("Segoe UI", 24, FontScaling.Pixel), System.Drawing.Color.White);
pedStreamer = new PedStreamer(this, 100.0f);
vehicleStreamer = new VehicleStreamer(this, 100.0f);
pedController = new PlayerPedController();
npcPedController = new NPCPedController();
vehicleController = new VehicleController();
playerVehicleController = new PlayerVehicleController();
chatController = new ChatController(this);
keyboardHandler = new KeyboardHandler(this);
currentState = ClientState.Initializing;
Interval = 80;
//cam = new Camera();
//cam.Activate();
currentState = ClientState.Disconnected;
System.IO.File.WriteAllText("multiv-log.txt", "");
perFrameRenderer = new PerFrameRenderer(this);
Player.Character.CurrentRoom = Room.FromString("R_00000000_00000000");
startTimersandBindEvents();
try
{
if (client != null && client.Connected)
{
client.Close();
}
client = new TcpClient();
IPAddress address = IPAddress.Parse(ip);
nick = nickname;
client.Connect(address, port);
Client.currentData = UpdateDataStruct.Zero;
serverConnection = new ServerConnection(this);
World.CurrentDayTime = new TimeSpan(12, 00, 00);
World.PedDensity = 0;
World.CarDensity = 0;
// AlternateHook.call(AlternateHook.OtherCommands.TERMINATE_ALL_SCRIPTS_FOR_NETWORK_GAME);
GTA.Native.Function.Call("CLEAR_AREA", 0.0f, 0.0f, 0.0f, 4000.0f, true);
currentState = ClientState.Connecting;
}
catch
{
currentState = ClientState.Disconnected;
if (client != null && client.Connected)
{
client.Close();
}
throw;
}
}
void Start()
{
Vehicle = gameObject.GetComponent<VehicleController>() as VehicleController;
ShootingBehaviour = gameObject.GetComponentInChildren<ShootingBehaviour>() as ShootingBehaviour;
TankTurret = gameObject.GetComponentInChildren<TankTurretBehaviour>() as TankTurretBehaviour;
Manager = Object.FindObjectOfType(typeof(MatchManager)) as MatchManager;
}
void Start()
{
car = GetComponentInChildren<VehicleController>();
}
