Waypoints[] ConvertTargets(Object[] targets) { Waypoints[] result =new Waypoints[targets.Length]; for(int i = 0; i < targets.Length; i++){ result[i] = targets[i] as Waypoints; } return result; }
// Use this for initialization void Start() { // FIXME Set target should be called from another script SetTarget(Target); GotCar = false; GameObject WaypointObject = GameObject.Find("Waypoints"); WaypointScript = WaypointObject.GetComponent<Waypoints>(); }
// Use this for initialization void Awake() { if(!next){ Debug.LogWarning("There is no next waypoint"); } if(isStart){ start = this; } }
public void Save_CheckIfTheItemsArePersist_ResultTheSameTripCollection() { WaypointsRepository repository = WaypointsRepositoryFactory.Create(); Waypoints waypoints = new Waypoints(); waypoints.Add(CreateWaypoint()); Task.Run(() => repository.SaveAsync(waypoints)).Wait(); Waypoints savedWaypoints = null; Task.Run(() => savedWaypoints = repository.LoadAsync().Result).Wait(); Assert.AreEqual(1, savedWaypoints.Count); Assert.IsNotNull(savedWaypoints[0].Position); }
void Update() { //direçao atual Vector3 dir = destino-this.transform.position; //anula o y dir.y = 0; //se a distancia (magnitude) for pequena, chegou no destino if(dir.magnitude < 0.5f){ //escolhe um destino aleatorio //isso pode virar uma funçao que escolhe algum dos waypoints a frente dele //se nao tiver nenhum waypoint na frente dele ai sim ele pode escolher algum atraz way = way.nexts[Random.Range(0,way.nexts.Count)]; //nova direçao pro novo alvo Vector3 newDir = (way.transform.position- this.transform.position).normalized; //o destino fica ao lado do waypoint //so pegar a direçao e girar 90º em y //pra girar um vetor vc multiplica por um quaternion //o desvio diz quanto vai desviar pro lado (positivo ou negativo) destino = way.transform.position + Quaternion.Euler(0,90,0) * newDir * desvio; //guarda a nova direçao ignorando o y dir = newDir; dir.y = 0; } //rotaciona o personagem para ficar de frente pro destino this.transform.rotation = Quaternion.LookRotation(dir, Vector3.up); //usa a velocidade atual e muda apenas x e z //o y e controlado pela gravidade Vector3 vel = this.GetComponent<Rigidbody>().velocity; dir = dir.normalized; vel.x = dir.x * speed; vel.z = dir.z * speed; this.GetComponent<Rigidbody>().velocity = vel; }
public MainPageViewModel(IUiService uiService, MenuBarViewModel menuBarViewModel) : base(uiService) { AddLocationsPopup = menuBarViewModel; IsAddLocationsPopupVisible = false; LoadAddLocationsPopupMenuItems(); DisplayName = "Where Am I"; WaypointsRepository repository = WaypointsRepositoryFactory.Create(); Waypoints waypoints = new Waypoints(); waypoints.Add(CreateWaypoint()); Waypoints savedWaypoints = null; Task.Run(() => savedWaypoints = repository.LoadAsync().Result).Wait(); //TODO: Delete!!! if (savedWaypoints.Count == 0) { savedWaypoints.PopulateWithMockData(); repository.SaveAsync(savedWaypoints); } WaypointList = new ObservableCollection<Waypoint>(savedWaypoints.ToArray()); var location = GetCurrentLocation(); if (location == null) { MessageDialog message = new MessageDialog("GPSLocationNotResolved"); Task.Run(() => message.ShowAsync()).Wait(); } else { CurrentLocationLatitude = location.Latitude; CurrentLocationLongitude = location.Longitude; } }
void Start() { Wpoints = GameObject.FindGameObjectWithTag("Waypoints").GetComponent <Waypoints>(); maxIndex = Wpoints.waypoints.Length; timeBtwShots = startTimeBtwShots; }
} // end of GenerateMap #endregion #region Search Target /// <summary> /// Search target mode /// </summary> void SearchTarget() { WayPoint nextWaypoint = null; //set behavior //if (TargetFound) //{ // State = DriveState.GotoBall; // return; //} if (Waypoints.Count == 0 && usePathGen && !goToSafe) { State = DriveState.GenerateSearchPath; Speed = 0; Steering = 0; GenerateSearchPath(); usePathGen = false; goToSafe = true; State = DriveState.SearchTarget; } else if (Waypoints.Count == 0 && !usePathGen) { //State = DriveState.Idle; } if (Waypoints.Count > 0 && Waypoints.TryPeek(out nextWaypoint)) { if (nextWaypoint != null) { WayPoint currentLocation = new WayPoint(Latitude, Longitude, 0); WaypointVector = new Vector2d(currentLocation, nextWaypoint); NextWaypointDistance = WayPoint.GetDistance(this.Latitude, this.Longitude, nextWaypoint.Lat, nextWaypoint.Long); //// ************* Obstacle Avoidance Code ****************** nextWaypoint = obstacleAvoidance(nextWaypoint, currentLocation); // Everything is in meters and radians //if (Settings.UseVision) //{ // if (AvoidanceVector.magnitude > 0) // { // SumVector = new Vector2d(currentLocation, nextWaypoint); // SumVector.magnitude /= SumVector.magnitude; //Normalize(Check if normalize is needed) // SumVector.magnitude *= Alpha * MaxSpeed; // Influence(Check if maxspeed is needed) // AvoidanceVector.angle = (AvoidanceVector.angle + 90 + Heading);// Make Lidar data relative to robot position // SumVector += AvoidanceVector; //combine Avoidance and Attraction vector // SumVector.magnitude = Math.Max(ReachWaypointZone + 1, SumVector.magnitude); //set the minimum vector length to 4 meters // nextWaypoint = WayPoint.Projection(currentLocation, SumVector.angle, SumVector.magnitude); // } //} /*if (Settings.DriveMode == DriveMode.Autonomous) * { * Speed = * }*/ NextWaypointBearing = WayPoint.GetBearing(this.Latitude, this.Longitude, nextWaypoint.Lat, nextWaypoint.Long); //calculate difference angle double errorWaypoint = NextWaypointBearing - Heading; if (errorWaypoint > Math.PI) { errorWaypoint -= Math.PI * 2.0; } else if (errorWaypoint < -Math.PI) { errorWaypoint += Math.PI * 2.0; } NextWaypointBearingError = errorWaypoint; } //else // State = DriveState.Idle; if (imu.GoodData) { //if use gps only to drive //apply steer control double TempSteering = NextWaypointBearingError * SteerRatio / Math.PI; // SteerPID.Feed(error); Steering = CloseBoundary ? Math.Min(Math.Max(TempSteering, -1000), 1000) : Math.Min(Math.Max(TempSteering * OutsideSteerRatio, -1000), 1000); //set speed Speed = InsideBoundary ? FullSpeed : FullSpeed * OutsideSpeedRatio; } else { //set all to 0 if no gps lock Speed = 0; Steering = 0; } //only reach target when drive auto if (Settings.DriveMode == DriveMode.Autonomous || Settings.DriveMode == DriveMode.SemiAutonomous) { //check if reached if (NextWaypointDistance < ReachWaypointZone) { Waypoints.TryDequeue(out nextWaypoint); } //TargetDistance = WayPoint.GetDistance(this.Latitude, this.Longitude, TargetWaypoint.Lat, TargetWaypoint.Long); //if (TargetDistance < ReachWaypointZone) // State=DriveState.GrabPayloadManual; } } else { Speed = 0; Steering = 0; State = DriveState.Idle; } }
private void OnDeleteSelectedItem(object obj) { WaypointList.Remove(SelectedWaypointItem); var availableWaipoints = new Waypoints(); availableWaipoints.AddRange(WaypointList); Task.Run(() => _repository.SaveAsync(availableWaipoints)); NotifyOfPropertyChange(() => WaypointList); }
public void AddWaypoint (TrackPoint waypoint) { Waypoints.Add (waypoint); }
private void SpawnSpheres() { float dx = -54.7146f; float dy = y; float dz = z; for (var i = 0; i < 8; i++) { var o = GameObject.CreatePrimitive(PrimitiveType.Sphere); o.tag = "Drug"; o.transform.localScale = new Vector3(SphereSize, SphereSize, SphereSize); var color = new Color(200, 0, 0, 255); MeshRenderer gameObjectRenderer = o.GetComponent <MeshRenderer>(); Material newMaterial = new Material(Shader.Find("Standard")); newMaterial.color = color; gameObjectRenderer.material = newMaterial; o.AddComponent <Movement>(); var parent = GameObject.Find("Panel17").transform; o.transform.parent = parent; Movement so = o.GetComponent <Movement>(); so.lerpTime = so.lerpTime - subtract; o.transform.localScale = new Vector3(2f, 2f, 2f); if (i % 2 == 0) { so.waypoints = Waypoints.GetWaypoints("Urinary"); o.transform.localPosition = new Vector3(-54.7146f, 2.1792f, -267.04f); } else { so.waypoints = Waypoints.GetWaypoints("Urinary2"); o.transform.localPosition = new Vector3(-18f, 2.2f, -267.04f); } subtract -= .15f; //o.transform.localPosition = new Vector3(-54.7146f, 2.1792f, -267.04f); dx += 2.2f; } /*for (var i = 0; i < 4; i++) * { * //var planePos = GameObject.Find("Plane").bounds; * var o = GameObject.CreatePrimitive(PrimitiveType.Sphere); * o.tag = "Drug"; * o.transform.localScale = new Vector3(SphereSize, SphereSize, SphereSize); * * var color = new Color(200, 0, 0, 255); * MeshRenderer gameObjectRenderer = o.GetComponent<MeshRenderer>(); * * Material newMaterial = new Material(Shader.Find("Standard")); * newMaterial.color = color; * gameObjectRenderer.material = newMaterial; * * //var type = Type.GetType( "Movement" ); * o.AddComponent<Movement>(); * var parent = GameObject.Find("Panel17").transform; * o.transform.parent = parent; * Movement mov = o.GetComponent<Movement>(); * mov.lerpTime = .5f; * * mov.waypoints = Waypoints.GetWaypoints("Urinary2"); * * * * o.transform.localScale = new Vector3(2f, 2f, 2f); * o.transform.localPosition = new Vector3(-18f, 2.2f, -267.04f); * dx += 2.2f; * }*/ }
protected override QueryStringParametersList GetQueryStringParameters() { if (string.IsNullOrWhiteSpace(Origin)) { throw new ArgumentException("Must specify an Origin"); } if (string.IsNullOrWhiteSpace(Destination)) { throw new ArgumentException("Must specify a Destination"); } if (!Enum.IsDefined(typeof(AvoidWay), Avoid)) { throw new ArgumentException("Invalid enumeration value for 'Avoid'"); } if (!Enum.IsDefined(typeof(TravelMode), TravelMode)) { throw new ArgumentException("Invalid enumeration value for 'TravelMode'"); } if (TravelMode == TravelMode.Transit && (DepartureTime == default(DateTime) && ArrivalTime == default(DateTime))) { throw new ArgumentException("You must set either DepatureTime or ArrivalTime when TravelMode = Transit"); } var parameters = base.GetQueryStringParameters(); parameters.Add("origin", Origin); parameters.Add("destination", Destination); parameters.Add("mode", TravelMode.ToString().ToLower()); if (Alternatives) { parameters.Add("alternatives", "true"); } if (Avoid != AvoidWay.Nothing) { parameters.Add("avoid", Avoid.ToString().ToLower()); } if (!string.IsNullOrWhiteSpace(Language)) { parameters.Add("language", Language); } if (!string.IsNullOrWhiteSpace(Region)) { parameters.Add("region", Region); } if (Waypoints != null && Waypoints.Any()) { IEnumerable <string> waypoints; if (OptimizeWaypoints) { const string optimizeWaypoints = "optimize:true"; waypoints = new string[] { optimizeWaypoints }.Concat(Waypoints); } else { waypoints = Waypoints; } parameters.Add("waypoints", string.Join("|", waypoints)); } if (ArrivalTime != default(DateTime)) { parameters.Add("arrival_time", UnixTimeConverter.DateTimeToUnixTimestamp(ArrivalTime).ToString(CultureInfo.InvariantCulture)); } if (DepartureTime != default(DateTime)) { parameters.Add("departure_time", UnixTimeConverter.DateTimeToUnixTimestamp(DepartureTime).ToString(CultureInfo.InvariantCulture)); } return(parameters); }
public SaveResult(Waypoints waypoints) { _waypoints = waypoints; }
void Start() { Wpoints = GameObject.FindGameObjectWithTag("Waypoints").GetComponent <Waypoints>(); }
public Vector2[] GetWaypoints() { return(Waypoints.ToArray()); }
public void SetWaypoint(Waypoints waypoint) { wps [wp].gameObject.SetActive(true); wps [wp].newWaypoint.Invoke(); }
// Start is called before the first frame update void Start() { command.onClick.AddListener(TaskOnClick); remove = (removeButtons)FindObjectOfType(typeof(removeButtons)); waypoints = (Waypoints)FindObjectOfType(typeof(Waypoints)); }
/// <summary> Reloads this object. </summary> /// /// <remarks> Bunny 2, 3/14/2014. </remarks> public void Reload() { XmlSerializationHelper.Serialize(waypointFile, _Waypoints); _Waypoints = XmlSerializationHelper.Deserialize<Waypoints>(waypointFile); }
// Start est appelé juste avant qu'une méthode Update soit appelée pour la première fois protected override void Start() { base.Start(); this.waypoints = Waypoints.GetPoints(); this.WaypointTarget = waypoints[waypointIndex]; }
Equals(Waypoints, other.Waypoints) &&
internal void Restart(DataWaypoint newOrigin) { Waypoints.Clear(); Waypoints.AddLast(newOrigin); }
public void Reload() { XmlSerializationHelper.Serialize(InterProcessCom.ConfigPath + "\\waypoints.xml", _Waypoints); _Waypoints = XmlSerializationHelper.Deserialize<Waypoints>(InterProcessCom.ConfigPath + "\\waypoints.xml"); }
/// <summary> /// Create a TripEventArgs for a Trigger or Signal origin, /// with the given visitor identifier and origin info. /// </summary> /// <param name="visitorId"></param> /// <param name="tripOrigin"></param> public TripEventArgs(IDisposable visitorId, DataWaypoint tripOrigin) { VisitorIdentifier = visitorId; Waypoints.AddLast(tripOrigin); }
/// <summary> /// Update the active route for the character /// </summary> private async void UpdateActiveRoute() { if (Waypoints.Count == 0) { return; } { // new routing string start = string.Empty; string end = Location; Application.Current.Dispatcher.Invoke((Action)(() => { lock (ActiveRouteLock) { if (Location == Waypoints[0]) { Waypoints.RemoveAt(0); } } ActiveRoute.Clear(); }), DispatcherPriority.Normal); // loop through all the waypoints for (int i = 0; i < Waypoints.Count; i++) { start = end; end = Waypoints[i]; List <Navigation.RoutePoint> sysList = Navigation.Navigate(start, end, UseAnsiblexGates, false, NavigationMode); if (sysList != null) { Application.Current.Dispatcher.Invoke((Action)(() => { lock (ActiveRouteLock) { foreach (Navigation.RoutePoint s in sysList) { ActiveRoute.Add(s); } } }), DispatcherPriority.Normal, null); } } } if (esiRouteNeedsUpdate && !esiRouteUpdating) { esiRouteNeedsUpdate = false; esiRouteUpdating = true; List <long> WayPointsToAdd = new List <long>(); lock (ActiveRouteLock) { foreach (Navigation.RoutePoint rp in ActiveRoute) { // explicitly add interim waypoints for ansiblex gates or actual waypoints if (rp.GateToTake == Navigation.GateType.Ansibex || Waypoints.Contains(rp.SystemName)) { long wayPointSysID = EveManager.Instance.GetEveSystem(rp.SystemName).ID; if (rp.GateToTake == Navigation.GateType.Ansibex) { foreach (JumpBridge jb in EveManager.Instance.JumpBridges) { if (jb.From == rp.SystemName) { if (jb.FromID != 0) { wayPointSysID = jb.FromID; } break; } if (jb.To == rp.SystemName) { if (jb.ToID != 0) { wayPointSysID = jb.ToID; } break; } } } WayPointsToAdd.Add(wayPointSysID); } } } bool firstRoute = true; foreach (long SysID in WayPointsToAdd) { ESI.NET.EsiClient esiClient = EveManager.Instance.ESIClient; esiClient.SetCharacterData(ESIAuthData); ESI.NET.EsiResponse <string> esr = await esiClient.UserInterface.Waypoint(SysID, false, firstRoute); if (EVEData.ESIHelpers.ValidateESICall(esr)) { // routeNeedsUpdate = true; } firstRoute = false; // with a shorter wait, ive found the occasional out of order route Thread.Sleep(200); } esiRouteUpdating = false; } }
public void Init(EdgeCollider2D edgePath, ShipStats shipStats) { this.shipStats = shipStats; waypoints = new Waypoints(); waypoints.Init(enemyBehaviour, edgePath); }
// Use this for initialization void Start() { waypointscript = gameObject.GetComponentInParent <Waypoints> (); }
private Waypoints GetWaypointsList(string fname, bool reverse) { float len = 0; Waypoints waypoints = new Waypoints(fname); Vector3D v_prev = MakeVector(dgWaypoints.Rows[0]); waypoints.Add(v_prev); for (int i = 1; i < dgWaypoints.Rows.Count - 1; i++) { Vector3D v_cur = MakeVector(dgWaypoints.Rows[i]); len += v_prev.GetDistanceTo(v_cur); waypoints.Add(v_cur); v_prev = v_cur; } if (reverse) waypoints.List.Reverse(); return waypoints; }
/// <summary> /// Clears the waypoints and grid. /// </summary> public void ClearWaypointsAndGrid() { Waypoints.Clear(); }
public void SeekWaypoint(int i, Waypoints Waypoint) { AIRacerScript.AIRacerList[i].DesiredPosition = Waypoint.CentrePosition; AIRacerScript.AIRacerList[i].SteeringForce = AISteeringBehaviour.SeekOrFlee(AIRacerScript.AIRacerList[i].CurrentPosition, AIRacerScript.AIRacerList[i].DesiredPosition, AIRacerScript.AIRacerList[i].CurrentMaxSpeed, AIRacerScript.AIRacerList[i].CurrentDirection, true); }
/// <summary> /// Spawn an enemy NPC type /// </summary> /// <param name="parent">The parent GameObject where this gameObject should be spawned</param> /// <param name="spawnPoint">Where in the World this gameObject should spawn</param> /// <param name="pathogensController">The PathogensController used to control the NPC</param> /// <param name="pathogenObject">The data of the pathogen we are spawining</param> /// <param name="waypoints">The list of waypoints the cell should follow</param> public void SpawnEnemy(Transform parent, Transform spawnPoint, PathogensController pathogensController, PathogenObject pathogenObject, Waypoints waypoints) { var newEnemy = Instantiate(pathogenPrefab, spawnPoint.position, spawnPoint.rotation, parent); newEnemy.controller = pathogensController; newEnemy.pathogenObject = pathogenObject; newEnemy.waypointsContainer = waypoints.transform; EnemyPoints = newEnemy.pathogenObject.pathogenReward; // Execute the spawning callback newEnemy.onEnemySpawned?.Invoke(); newEnemy.onEnemyDestroyed.AddListener(() => -- AliveEnemiesCount); }
public override bool add(GpxModel oldModel, GpxModel newModel, PasteMode mode) { bool retVal = true; int index = -1; switch (mode) { case PasteMode.BEGINNING: { if (newModel is GpxTrackModel trkModel) { trkModel.Parent = this; Tracks.Insert(0, trkModel); } if (newModel is GpxRouteModel rteModel) { rteModel.Parent = this; Routes.Insert(0, rteModel); } if (newModel is GpxWaypointModel wptModel) { wptModel.Parent = this; Waypoints.Insert(0, wptModel); } break; } case PasteMode.BEFORE: { if (newModel is GpxTrackModel trkModel) { index = Tracks.IndexOf((GpxTrackModel)oldModel); if (index == -1) { retVal = false; } else { trkModel.Parent = this; Tracks.Insert(index, trkModel); } } if (newModel is GpxRouteModel rteModel) { index = Routes.IndexOf((GpxRouteModel)oldModel); if (index == -1) { retVal = false; } else { rteModel.Parent = this; Routes.Insert(index, rteModel); } } if (newModel is GpxWaypointModel wptModel) { index = Waypoints.IndexOf((GpxWaypointModel)oldModel); if (index == -1) { retVal = false; } else { wptModel.Parent = this; Waypoints.Insert(index, wptModel); } } break; } case PasteMode.AFTER: { if (newModel is GpxTrackModel trkModel) { index = Tracks.IndexOf((GpxTrackModel)oldModel); trkModel.Parent = this; Tracks.Insert(index + 1, trkModel); } if (newModel is GpxRouteModel rteModel) { index = Routes.IndexOf((GpxRouteModel)oldModel); rteModel.Parent = this; Routes.Insert(index + 1, rteModel); } if (newModel is GpxWaypointModel wptModel) { index = Waypoints.IndexOf((GpxWaypointModel)oldModel); wptModel.Parent = this; Waypoints.Insert(index + 1, wptModel); } break; } case PasteMode.END: { if (newModel is GpxTrackModel trkModel) { trkModel.Parent = this; Tracks.Add(trkModel); } if (newModel is GpxRouteModel rteModel) { rteModel.Parent = this; Routes.Add(rteModel); } if (newModel is GpxWaypointModel wptModel) { wptModel.Parent = this; Waypoints.Add(wptModel); } break; } } return(retVal); }
/// <summary> /// Drive to safe zone /// </summary> void DriveToSafeZone() { WayPoint nextWaypoint = null; //set behavior if (Waypoints.Count > 0 && Waypoints.TryPeek(out nextWaypoint)) { if (nextWaypoint != null) { NextWaypointBearing = WayPoint.GetBearing(this.Latitude, this.Longitude, nextWaypoint.Lat, nextWaypoint.Long); NextWaypointDistance = WayPoint.GetDistance(this.Latitude, this.Longitude, nextWaypoint.Lat, nextWaypoint.Long); //calculate difference angle double errorWaypoint = NextWaypointBearing - Heading; if (errorWaypoint > Math.PI) { errorWaypoint -= Math.PI * 2.0; } else if (errorWaypoint < -Math.PI) { errorWaypoint += Math.PI * 2.0; } NextWaypointBearingError = errorWaypoint; //vision VisionWayPoint nextVisionWaypoint = null; VisionWayPoint[] tempVisionWaypoints = VisionWaypoints.ToArray(); if (tempVisionWaypoints.Length > 0) { nextVisionWaypoint = tempVisionWaypoints[0]; NextVisionBearing = WayPoint.GetBearing(this.Latitude, this.Longitude , nextVisionWaypoint.X, nextVisionWaypoint.Y); NextVisionDistance = WayPoint.GetDistance(this.Latitude, this.Longitude , nextVisionWaypoint.X, nextVisionWaypoint.Y); //calculate difference angle double errorVision = NextVisionBearing - Heading; if (errorVision > Math.PI) { errorVision -= Math.PI * 2.0; } else if (errorVision < -Math.PI) { errorVision += Math.PI * 2.0; } NextVisionBearingError = errorVision; } if (imu.GoodData) { //wait for distance to reach if (NextWaypointDistance < ReachWaypointZone && InsideSafeZone) { //when reach stop and wait for drop Speed = 0; Steering = 0; //clear waypoints and wait drop Waypoints = new System.Collections.Concurrent.ConcurrentQueue <WayPoint>(); this.State = DriveState.WaitDrop; } //if use vision to drive if (Settings.UseVision && nextVisionWaypoint != null) { //avoid 500 500 if (nextVisionWaypoint.X > 360.0 || nextVisionWaypoint.Y > 360.0) { WayPoint wp = WayPoint.GenerateRandomWaypoint(SafeZone); if (wp != null) { WayPoint temp; Waypoints.TryDequeue(out temp); Waypoints.Enqueue(wp); return; } } //apply steer control double TempSteering = 0; //apply speed control double TempSpeed = 0; //determine behavior TempSteering = NextVisionBearingError * SteerRatio / Math.PI; TempSpeed = FullSpeed; TargetApporachCount = 0; Steering = CloseBoundary ? Math.Min(Math.Max(TempSteering, -1000), 1000) : Math.Min(Math.Max(TempSteering * OutsideSteerRatio, -1000), 1000); //set speed Speed = InsideBoundary ? TempSpeed : TempSpeed * OutsideSpeedRatio; } //if use gps only to drive else { //apply steer control double TempSteering = NextWaypointBearingError * SteerRatio / Math.PI; // SteerPID.Feed(error); Steering = CloseBoundary ? Math.Min(Math.Max(TempSteering, -1000), 1000) : Math.Min(Math.Max(TempSteering * OutsideSteerRatio, -1000), 1000); //set speed Speed = InsideBoundary ? FullSpeed : FullSpeed * OutsideSpeedRatio; } } else { //set all to 0 if no gps lock Speed = 0; Steering = 0; } } } else { //if target not found if (Waypoints.Count == 0) { WayPoint wp = WayPoint.GetCenter(SafeZone); if (wp != null) { Waypoints.Enqueue(wp); } } //set all to 0 if no waypoints Speed = 0; Steering = 0; } }
/// <summary> /// Removes all elements in scope from the instance. /// </summary> /// <param name="theTier">The tier to remove the elements from.</param> /// <param name="xMin">The min x-value of the scope.</param> /// <param name="xMax">The max x-value of the scope.</param> /// <param name="yMin">The min y-value of the scope.</param> /// <param name="yMax">The max y-value of the scope.</param> public void ModRemoveWaypoints(ITierInfo theTier, double xMin, double yMin, double xMax, double yMax) { Tier tier = theTier as Tier; // Remove waypoints List <Waypoint> remWaypoints = Waypoints.Where(w => w.Tier == tier && xMin <= w.X && w.X <= xMax && yMin <= w.Y && w.Y <= yMax).ToList(); // Remove all of them foreach (var waypoint in remWaypoints) { // Remove the waypoint - the waypoint graph handles all cascading path removals waypoint.Tier.RemoveWaypoint(waypoint); // Remove all elements that were connected to the waypoint foreach (var guard in Semaphores.SelectMany(s => s.Guards).Where(guard => guard.From == waypoint || guard.To == waypoint).ToArray()) { guard.Semaphore.UnregisterGuard(guard); if (guard.Semaphore.Guards.Count() == 0) { Semaphores.Remove(guard.Semaphore); } } foreach (var station in InputStations.Where(s => s.Waypoint == waypoint).ToArray()) { station.Tier.RemoveInputStation(station); InputStations.Remove(station); } foreach (var station in OutputStations.Where(s => s.Waypoint == waypoint).ToArray()) { station.Tier.RemoveOutputStation(station); OutputStations.Remove(station); } foreach (var pod in Pods.Where(p => p.Waypoint == waypoint).ToArray()) { pod.Tier.RemovePod(pod); Pods.Remove(pod); } foreach (var elevator in Elevators.Where(e => e.ConnectedPoints.Contains(waypoint))) { elevator.UnregisterPoint(waypoint); if (elevator.ConnectedPoints.Count == 0) { Elevators.Remove(elevator); } } // Make sure it is not on the list of storage locations anymore if (waypoint.PodStorageLocation) { ResourceManager.RemovePodStorageLocation(waypoint); } // Finally remove from the overall waypoint list Waypoints.Remove(waypoint); } // Also remove movables in scope List <Bot> remBots = Bots.Where(b => b.Tier == tier && xMin <= b.X && b.X <= xMax && yMin <= b.Y && b.Y <= yMax).ToList(); foreach (var bot in remBots) { Bots.Remove(bot); bot.Tier.RemoveBot(bot); } List <Pod> remPods = Pods.Where(p => p.Tier == tier && xMin <= p.X && p.X <= xMax && yMin <= p.Y && p.Y <= yMax).ToList(); foreach (var pod in remPods) { Pods.Remove(pod); pod.Tier.RemovePod(pod); } }
void Awake() { waypoints = FindObjectOfType <Waypoints>(); }
public bool CreatePathInsideBoundary(IntPoint startPointIn, IntPoint endPointIn, Polygon pathThatIsInside, bool optomizePath = true) { double z = startPointIn.Z; startPointIn.Z = 0; endPointIn.Z = 0; if (BoundaryPolygons == null || BoundaryPolygons.Count == 0) { return(false); } // neither needed to be moved if (BoundaryPolygons.FindIntersection(startPointIn, endPointIn, BoundaryEdgeQuadTrees) == Intersection.None && BoundaryPolygons.PointIsInside((startPointIn + endPointIn) / 2, BoundaryEdgeQuadTrees, BoundaryPointQuadTrees)) { return(true); } removePointList.Dispose(); pathThatIsInside.Clear(); //Check if we are inside the boundaries IntPointNode startPlanNode = null; var lastAddedNode = GetWayPointInside(startPointIn, out startPlanNode); IntPointNode endPlanNode = null; var lastToAddNode = GetWayPointInside(endPointIn, out endPlanNode); long startToEndDistanceSqrd = (endPointIn - startPointIn).LengthSquared(); long moveStartInDistanceSqrd = (startPlanNode.Position - lastAddedNode.Position).LengthSquared(); long moveEndInDistanceSqrd = (endPlanNode.Position - lastToAddNode.Position).LengthSquared(); if (startToEndDistanceSqrd < moveStartInDistanceSqrd || startToEndDistanceSqrd < moveEndInDistanceSqrd) { return(true); } var crossings = new List <Tuple <int, int, IntPoint> >(BoundaryPolygons.FindCrossingPoints(lastAddedNode.Position, lastToAddNode.Position, BoundaryEdgeQuadTrees)); crossings.Sort(new PolygonAndPointDirectionSorter(lastAddedNode.Position, lastToAddNode.Position)); foreach (var crossing in crossings.SkipSame()) { IntPointNode crossingNode = Waypoints.FindNode(crossing.Item3, findNodeDist); // for every crossing try to connect it up in the waypoint data if (crossingNode == null) { crossingNode = AddTempWayPoint(removePointList, crossing.Item3); // also connect it to the next and prev points on the polygon it came from HookUpToEdge(crossingNode, crossing.Item1, crossing.Item2); } if (lastAddedNode != crossingNode && BoundaryPolygons.PointIsInside((lastAddedNode.Position + crossingNode.Position) / 2, BoundaryEdgeQuadTrees, BoundaryPointQuadTrees)) { Waypoints.AddPathLink(lastAddedNode, crossingNode); } else if (crossingNode.Links.Count == 0) { // link it to the edge it is on HookUpToEdge(crossingNode, crossing.Item1, crossing.Item2); } lastAddedNode = crossingNode; } if (lastAddedNode != lastToAddNode && BoundaryPolygons.PointIsInside((lastAddedNode.Position + lastToAddNode.Position) / 2, BoundaryEdgeQuadTrees)) { // connect the last crossing to the end node Waypoints.AddPathLink(lastAddedNode, lastToAddNode); } Path <IntPointNode> path = Waypoints.FindPath(startPlanNode, endPlanNode, true); foreach (var node in path.Nodes.SkipSamePosition()) { pathThatIsInside.Add(new IntPoint(node.Position, z)); } if (path.Nodes.Length == 0) { if (saveBadPathToDisk) { WriteErrorForTesting(startPointIn, endPointIn, 0); } CalculatedPath?.Invoke(this, pathThatIsInside, startPointIn, endPointIn); return(false); } if (optomizePath) { OptomizePathPoints(pathThatIsInside); } if (saveBadPathToDisk) { AllPathSegmentsAreInsideOutlines(pathThatIsInside, startPointIn, endPointIn, true); } CalculatedPath?.Invoke(this, pathThatIsInside, startPointIn, endPointIn); return(true); }
/// <summary> /// Moves the object to its specified waypoints, updating its coordinate. /// </summary> /// <param name="diff">The amount of milliseconds the object is supposed to move</param> public void Move(float diff, bool useTarget = false) { // no waypoints remained - clear the Waypoints if (WaypointIndex >= Waypoints.Count) { Waypoints.RemoveAll(v => v != Waypoints[0]); } // TODO: Remove dependency of Target. In fact, just remove Target altogether. if (Target == null) { _direction = new Vector2(); return; } // current position var cur = new Vector2(X, Y); var next = new Vector2(Target.X, Target.Y); var goingTo = next - cur; _direction = Vector2.Normalize(goingTo); // usually doesn't happen if (float.IsNaN(_direction.X) || float.IsNaN(_direction.Y)) { _direction = new Vector2(0, 0); } var moveSpeed = GetMoveSpeed(); var deltaMovement = moveSpeed * 0.001f * diff; var xx = _direction.X * deltaMovement; var yy = _direction.Y * deltaMovement; X += xx; Y += yy; // (X, Y) have now moved to the next position cur = new Vector2(X, Y); // Check if we reached the next waypoint // REVIEW (of previous code): (deltaMovement * 2) being used here is problematic; if the server lags, the diff will be much greater than the usual values if ((cur - next).LengthSquared() < MOVEMENT_EPSILON * MOVEMENT_EPSILON) { if (this is IProjectile && !Target.IsSimpleTarget) { return; } // remove this waypoint because we have reached it if (++WaypointIndex >= Waypoints.Count) { Target = null; } else { Target = new Target(Waypoints[WaypointIndex]); } } }
public PathFinder(Polygons outlinePolygons, long avoidInset, IntRect?stayInsideBounds = null) { if (outlinePolygons.Count == 0) { return; } OutlinePolygons = FixWinding(outlinePolygons); OutlinePolygons = Clipper.CleanPolygons(OutlinePolygons, avoidInset / 60); InsetAmount = avoidInset; if (stayInsideBounds != null) { var boundary = stayInsideBounds.Value; OutlinePolygons.Add(new Polygon() { new IntPoint(boundary.minX, boundary.minY), new IntPoint(boundary.maxX, boundary.minY), new IntPoint(boundary.maxX, boundary.maxY), new IntPoint(boundary.minX, boundary.maxY), }); OutlinePolygons = FixWinding(OutlinePolygons); } BoundaryPolygons = OutlinePolygons.Offset(stayInsideBounds == null ? -avoidInset : -2 * avoidInset); BoundaryPolygons = FixWinding(BoundaryPolygons); OutlineEdgeQuadTrees = OutlinePolygons.GetEdgeQuadTrees(); OutlinePointQuadTrees = OutlinePolygons.GetPointQuadTrees(); BoundaryEdgeQuadTrees = BoundaryPolygons.GetEdgeQuadTrees(); BoundaryPointQuadTrees = BoundaryPolygons.GetPointQuadTrees(); foreach (var polygon in BoundaryPolygons) { Waypoints.AddPolygon(polygon); } // hook up path segments between the separate islands if (simpleHookup) // do a simple hookup { for (int indexA = 0; indexA < BoundaryPolygons.Count; indexA++) { var polyA = BoundaryPolygons[indexA]; if (polyA.GetWindingDirection() > 0) { Func <int, Polygon, bool> ConsiderPolygon = (polyIndex, poly) => { return(polyIndex != indexA && poly.GetWindingDirection() > 0); }; // find the closest two points between A and any other polygon IntPoint bestAPos = polyA.Center(); Func <int, IntPoint, bool> ConsiderPoint = (polyIndex, edgeEnd) => { if (OutlinePolygons.PointIsInside((bestAPos + edgeEnd) / 2, OutlineEdgeQuadTrees, OutlinePointQuadTrees)) { return(true); } return(false); }; var bestBPoly = BoundaryPolygons.FindClosestPoint(bestAPos, ConsiderPolygon, ConsiderPoint); if (bestBPoly.polyIndex == -1) { // find one that intersects bestBPoly = BoundaryPolygons.FindClosestPoint(bestAPos, ConsiderPolygon); } if (bestBPoly.polyIndex != -1) { bestAPos = polyA.FindClosestPoint(bestBPoly.Item3).Item2; var bestBResult = BoundaryPolygons[bestBPoly.Item1].FindClosestPoint(bestAPos, ConsiderPoint); IntPoint bestBPos = new IntPoint(); if (bestBResult.index != -1) { bestBPos = bestBResult.Item2; } else { // find one that intersects bestBPos = BoundaryPolygons[bestBPoly.Item1].FindClosestPoint(bestAPos).Item2; } bestAPos = polyA.FindClosestPoint(bestBPos).Item2; bestBPos = BoundaryPolygons[bestBPoly.Item1].FindClosestPoint(bestAPos).Item2; // hook the polygons up along this connection IntPointNode nodeA = Waypoints.FindNode(bestAPos); IntPointNode nodeB = Waypoints.FindNode(bestBPos); Waypoints.AddPathLink(nodeA, nodeB); } } } } else // hook up using thin lines code { // this is done with merge close edges and finding candidates // then joining the ends of the merged segments with the closest points Polygons thinLines; if (OutlinePolygons.FindThinLines(avoidInset * 2, 0, out thinLines)) { ThinLinePolygons = thinLines; for (int thinIndex = 0; thinIndex < thinLines.Count; thinIndex++) { var thinPolygon = thinLines[thinIndex]; if (thinPolygon.Count > 1) { Waypoints.AddPolygon(thinPolygon, false); } } Polygons allPolygons = new Polygons(thinLines); allPolygons.AddRange(BoundaryPolygons); for (int thinIndex = 0; thinIndex < thinLines.Count; thinIndex++) { var thinPolygon = thinLines[thinIndex]; if (thinPolygon.Count > 1) { // now hook up the start and end of this polygon to the existing way points var closestStart = allPolygons.FindClosestPoint(thinPolygon[0], (polyIndex, poly) => { return(polyIndex == thinIndex); }); var closestEnd = allPolygons.FindClosestPoint(thinPolygon[thinPolygon.Count - 1], (polyIndex, poly) => { return(polyIndex == thinIndex); }); // last point if (OutlinePolygons.PointIsInside((closestStart.Item3 + closestEnd.Item3) / 2, OutlineEdgeQuadTrees)) { IntPointNode nodeA = Waypoints.FindNode(closestStart.Item3); IntPointNode nodeB = Waypoints.FindNode(closestEnd.Item3); if (nodeA != null && nodeB != null) { Waypoints.AddPathLink(nodeA, nodeB); } } } } } } removePointList = new WayPointsToRemove(Waypoints); }
// Start is called before the first frame update void Start() { command = (Command)FindObjectOfType(typeof(Command)); waypoints = (Waypoints)FindObjectOfType(typeof(Waypoints)); remove = (removeButtons)FindObjectOfType(typeof(removeButtons)); }
public IEnumerable<IResult> Save() { var waypoint = new Waypoint { Title = this.Title, CreatedDate = DateTime.Now, Description = this.Description, Position = new GPSPosition { Latitude = this.Latitude, Longitude = this.Longitude, }, }; var waypoints = new Waypoints (); waypoints.Add(waypoint); yield return new SaveResult(waypoints); GoBack(); }
public Navigation() { var filepath = InterProcessCom.ConfigPath + "\\waypoints.xml"; _Waypoints = !File.Exists(filepath) ? new Waypoints() : XmlSerializationHelper.Deserialize<Waypoints>(filepath); }
public NavigationState(Waypoints waypoints, string lfs, string tooltip_text) : this(waypoints, _default_step_dist, lfs, tooltip_text) { }
public NavigationState(Waypoints waypoints, float step_dist, string lfs, string tooltip_text) { _wp = waypoints; Init(lfs, step_dist, tooltip_text); }
public string GetWayPointText() { string ClipboardText = "Waypoints\n==============\n"; lock (ActiveRouteLock) { foreach (Navigation.RoutePoint rp in ActiveRoute) { string WayPointText = string.Empty; long wayPointSysID = EveManager.Instance.GetEveSystem(rp.SystemName).ID; // explicitly add interim waypoints for ansiblex gates or actual waypoints if (rp.GateToTake == Navigation.GateType.Ansibex) { bool isSystemLink = true; if (rp.GateToTake == Navigation.GateType.Ansibex) { string GateDesto = string.Empty; foreach (JumpBridge jb in EveManager.Instance.JumpBridges) { if (jb.From == rp.SystemName) { if (jb.FromID != 0) { wayPointSysID = jb.FromID; isSystemLink = false; } GateDesto = jb.To; break; } if (jb.To == rp.SystemName) { if (jb.ToID != 0) { wayPointSysID = jb.ToID; isSystemLink = false; } GateDesto = jb.From; break; } } if (isSystemLink) { WayPointText = "Ansiblex: <url=showinfo:5//" + wayPointSysID + ">" + rp.SystemName + " » " + GateDesto + " </url>\n"; } else { WayPointText = "Ansiblex: <url=showinfo:35841//" + wayPointSysID + ">" + rp.SystemName + " » " + GateDesto + "</url>\n"; } } } if (Waypoints.Contains(rp.SystemName)) { // regular waypoint wayPointSysID = EveManager.Instance.GetEveSystem(rp.SystemName).ID; WayPointText = "<url=showinfo:5//" + wayPointSysID + ">" + rp.SystemName + "</url>\n"; } ClipboardText += WayPointText; } } return(ClipboardText); }