/// <summary> /// Generates the bounding waypoints of the acceptable U-Turn area given Rndf Hazards and specified exit and entry waypoints /// </summary> /// <returns></returns> public static Polygon uTurnBounds(Coordinates exit, ArbiterSegment segment) { // initialize the bounding box List<Coordinates> boundingBox = new List<Coordinates>(); // put in coords for every available lane foreach (ArbiterLane al in segment.Lanes.Values) { PointOnPath? pop = null; if (!al.IsInside(exit)) { ArbiterWaypoint aw = al.GetClosestWaypoint(exit, 10.0); if (aw != null) pop = al.PartitionPath.GetClosest(aw.Position); } else pop = al.PartitionPath.GetClosest(exit); if(pop != null) { ArbiterLanePartition alp = al.GetClosestPartition(exit); Coordinates vector = alp.Vector().Normalize(15); Coordinates back = pop.Value.pt - vector; vector = vector.Normalize(30); boundingBox.AddRange(InflatePartition(back, vector, alp.Lane.Width)); } } // return the box return GeneralToolkit.JarvisMarch(boundingBox); }
public NavigableEdge GetClosestNavigableEdge(Coordinates c) { try { int i = this.RecommendedPath.GetClosestPoint(c).Index; Coordinates rpi = this.RecommendedPath[i]; for (int j = 0; j < PathNodes.Count; j++) { INavigableNode inn = PathNodes[j]; if (inn.Position.Equals(rpi)) { foreach (NavigableEdge ne in inn.OutgoingConnections) { if (ne.End.Equals(PathNodes[j + 1])) return ne; } } } } catch (Exception) { } return null; }
public Rectangle(int ax, int ay, int bx, int by, int cx, int cy, int dx, int dy) { A = new Coordinates { X = ax, Y = ay }; B = new Coordinates { X = bx, Y = by }; C = new Coordinates { X = cx, Y = cy }; D = new Coordinates { X = dx, Y = dy }; }
public LocalMapCluster(Coordinates position, double speed, Coordinates heading, double width) { this.position = position; this.speed = speed; this.heading = heading; this.width = width; }
public static void ComputeMeanCovariance(IList<Coordinates> pts, out Coordinates mean, out Matrix2 cov) { // for better numerical stability, use a two-pass method where we first compute the mean double sum_x = 0, sum_y = 0; for (int i = 0; i < pts.Count; i++) { sum_x += pts[i].X; sum_y += pts[i].Y; } double avg_x = sum_x/(double)pts.Count; double avg_y = sum_y/(double)pts.Count; // now compute variances and covariances double sum_x2 = 0, sum_y2 = 0, sum_xy = 0; for (int i = 0; i < pts.Count; i++) { double dx = pts[i].X - avg_x; double dy = pts[i].Y - avg_y; sum_x2 += dx*dx; sum_y2 += dy*dy; sum_xy += dx*dy; } double var_x = sum_x2/(double)pts.Count; double var_y = sum_y2/(double)pts.Count; double cov_xy = sum_xy/(double)pts.Count; mean = new Coordinates(avg_x, avg_y); cov = new Matrix2(var_x, cov_xy, cov_xy, var_y); }
public Track(string id, Coordinates coords, TimeStamp[] whens, Orientation[] angles) { this.id = id; this.coords = coords; this.whens = whens; this.angles = angles; }
public static Rover CreateRover(string definition) { if (string.IsNullOrEmpty(definition)) throw new WrongRoverDefinitionException("Definition of rover is empty."); var coordinatesAndOrientation = definition.Split(' '); if(coordinatesAndOrientation.Length != 3) throw new WrongRoverDefinitionException("Definition of rover doesn't have the proper format."); Coordinates coordinates; IOrientation orientation; try { coordinates = new Coordinates(Convert.ToInt32(coordinatesAndOrientation[0]), Convert.ToInt32(coordinatesAndOrientation[1])); orientation = OrientationFactory.GenerateOrientation(coordinatesAndOrientation[2]); } catch (Exception ex) { throw new WrongRoverDefinitionException("Bad definition.", ex); } var rover = new Rover(); rover.Init(coordinates, orientation); return rover; }
public Goblin(string name,Coordinates position) { this.Name = name; this.Position = position; this.Health = 50; this.Damage = 5; }
private bool WillCollideWith(GameObject obj, Coordinates direction, GameObject cur) { Coordinates first = new Coordinates( Math.Max(obj.Position.Row + direction.Row, cur.Position.Row), Math.Max(obj.Position.Col + direction.Col, cur.Position.Col) ); Coordinates last = new Coordinates( Math.Min(obj.Position.Row + obj.Rows + direction.Row, cur.Position.Row + cur.Rows), Math.Min(obj.Position.Col + obj.Cols + direction.Col, cur.Position.Col + cur.Cols) ); for (int row = first.Row; row < last.Row; row++) for (int col = first.Col; col < last.Col; col++) if (obj[row - obj.Position.Row - direction.Row, col - obj.Position.Col - direction.Col] != '\0' && cur[row - cur.Position.Row, col - cur.Position.Col] != '\0') return true; return false; }
/// <summary> /// Constructor /// </summary> /// <param name="position"></param> /// <param name="waypointId"></param> public ArbiterParkingSpotWaypoint(Coordinates position, ArbiterParkingSpotWaypointId waypointId, ArbiterParkingSpot parkingSpot) { this.position = position; this.WaypointId = waypointId; this.outgoingConnections = new List<NavigableEdge>(); }
public static SqlGeography CreatePolygon(Coordinates[] coordinates, int srid) { var list = coordinates.Distinct().ToList(); var b = new SqlGeographyBuilder(); b.SetSrid(srid); b.BeginGeography(OpenGisGeographyType.Polygon); b.BeginFigure(list[0].Latitude, list[0].Longitude); for (var i = 1; i < list.Count; i++) b.AddLine(list[i].Latitude, list[i].Longitude); b.AddLine(list[0].Latitude, list[0].Longitude); b.EndFigure(); b.EndGeography(); //Fix left-hand rule. We always want left-hand. var g = b.ConstructedGeography; if (!g.STIsValid()) throw new SisoDbException(ExceptionMessages.NotAValidPolygon.Inject(g.IsValidDetailed())); if (g.EnvelopeAngle() > 90) g = g.ReorientObject(); return g; }
public Amusements(Coordinates c, GameRecords m, int prize, int fee, int capacity, int runningTime, string name, bool hasEntranceExit, Color color, int typeId, int workingPrice, int attractiveness) : base(m, c, prize, typeId) { this.zIndex = 0; this.originalFee = fee; this.currFee = fee; this.capacity = capacity; this.WorkingCost = workingPrice; this.attractiveness = attractiveness; this.fixedRunningTime = runningTime; this.maxWaitingTime = (int)(runningTime*1.5); this.name = name; this.hasSeparatedEnterExit = hasEntranceExit; this.color = color; //this.typeId = typeId; peopleInList = new List<Person>(capacity); model.LastBuiltAmus = this; if(hasEntranceExit) model.mustBeEnter = true; this.Id = model.amusList.GetFreeID(); model.amusList.Add(this); model.maps.AddAmus(this); model.CheckCheapestFee(this.CurrFee); // mimoProvoz = true; // zacatek = true; }
private static double EvaluateGoalUtility(double curvature, Coordinates relativeGoalPoint) { // get the angle to the goal point double angle = relativeGoalPoint.ArcTan; const double angleMax = 45*Math.PI/180.0; double scaledAngle = angle/angleMax; if (scaledAngle > 1) scaledAngle = 1; if (scaledAngle < -1) scaledAngle = -1; // calculate the target curvature to hit the goal double targetCurvature = scaledAngle*max_curvature; // calculate a matching scale factor double scaleFactor = Math.Pow((curvature - targetCurvature)/0.01, 2); // calculate a distance weighting factor double distMin = 20; double distMax = 70; double distFactor = (relativeGoalPoint.Length - distMin)/(distMax - distMin); if (distFactor > 0.3) distFactor = 0.3; if (distFactor < 0) distFactor = 0; distFactor = 1-distFactor; double turnFactor = (1-scaleFactor*0.1); if (turnFactor < -1) turnFactor = -1; return turnFactor*distFactor; }
static void Main() { var startPosition = new Coordinates(0, 0); string[,] matrix = { { "1","3" ,"2", "2", "2" ,"4" }, { "3","3" ,"3", "2", "4" ,"4" }, { "4","3" ,"1", "2", "3" ,"3" }, { "4","3" ,"1", "3", "3" ,"1" }, { "4","3" ,"3", "3", "1" ,"1" }, }; var largestAreaCount = 0; for (int i = 0; i < matrix.GetLength(0); i++) { for (int j = 0; j < matrix.GetLength(1); j++) { if (matrix[i, j] != "V") { var currentAreaCount=FindMostAdjacentCells(matrix, i, j, matrix[i, j]); if (largestAreaCount < currentAreaCount) { largestAreaCount = currentAreaCount; } counter = 0; } } } Console.WriteLine(largestAreaCount); }
public Map(PhysicsEngine physicsEngine) { physicsEngine.AddItem(this); this.physicsEngine = physicsEngine; RequeredTicksToMove = 3; Position = new Coordinates(); Content = new Dictionary<Coordinates, char>(); for (int i = 0; i < mapFences.Length; i++) { mapFences[i] = new char[Globals.Y_MAX_BOARD_SIZE]; for (int j = 0; j < mapFences[i].Length; j++) { mapFences[i][j] = j % 3 == 1 ? Globals.BACKGROUND_DEFAULT_VALUE : '+'; } } var jsonText = File.ReadAllText(Globals.MODELS_PATH + "asd" + Globals.MODELS_FILES_EXTENSION); var deserializeObject = JsonConvert.DeserializeObject<MapStructure>(jsonText); Width = deserializeObject.MapWidth; Height = deserializeObject.MapLength; foreach (var mapObject in deserializeObject.map) { switch (mapObject.ClassType) { case "Services.Services.Objects.Obsticle": TakeObject(obsticlesFactory, mapObject); break; default: return; } } RecreateFences(); }
public void ExploredSparesRepresentedByO() { var minefield = Minefield.Unexplored(2, 3); var coordinates = new Coordinates(1, 2); var newMinefield = minefield.Explore(coordinates); Assert.AreEqual("XX\nXX\nXO\n", MinefieldRenderer.Render(newMinefield)); }
/// <summary> /// Checks if hte opposing lane is clear to pass an opposing vehicle /// </summary> /// <param name="lane"></param> /// <param name="state"></param> /// <returns></returns> public bool ClearForDisabledVehiclePass(ArbiterLane lane, VehicleState state, double vUs, Coordinates minReturn) { // update the forward vehicle this.ForwardVehicle.Update(lane, state); // check if the rear vehicle exists and is moving along with us if (this.ForwardVehicle.ShouldUseForwardTracker && this.ForwardVehicle.CurrentVehicle != null) { // distance from other to us double currentDistance = lane.DistanceBetween(this.ForwardVehicle.CurrentVehicle.ClosestPosition, state.Front) - (2 * TahoeParams.VL); double minChangeDist = lane.DistanceBetween(minReturn, state.Front); // check if he's within min return dist if(currentDistance > minChangeDist) { // params double vOther = this.ForwardVehicle.CurrentVehicle.StateMonitor.Observed.speedValid ? this.ForwardVehicle.CurrentVehicle.Speed : lane.Way.Segment.SpeedLimits.MaximumSpeed; // get distance of envelope for him to slow to our speed double xEnvelope = (Math.Pow(vUs, 2.0) - Math.Pow(vOther, 2.0)) / (2.0 * -0.5); // check to see if vehicle is outside of the envelope to slow down for us after 3 seconds double xSafe = currentDistance - minChangeDist - (xEnvelope + (vOther * 15.0)); return xSafe > 0 ? true : false; } else return false; } else return true; }
/// <summary> /// Gets a Coordinate from a address. /// </summary> /// <param name="appFullyQualifiedDomainName">The application fully qualified domain name. /// <remarks> /// <example>http://webservices.geneva3.webvisible.com</example> /// </remarks> /// </param> /// <param name="address">An address. /// <remarks> /// <example>1600 Amphitheatre Parkway Mountain View, CA 94043</example> /// </remarks> /// </param> /// <returns>A spatial coordinate that contains the latitude and longitude of the address.</returns> public static Coordinates GetCoordinates(string appFullyQualifiedDomainName, string address) { Coordinates coordinate = new Coordinates(); coordinate = GetGeoCoordinates(appFullyQualifiedDomainName, address); if (coordinate != null) { if (!string.IsNullOrEmpty(coordinate.ErrorMessage)) { throw new Exception(coordinate.ErrorMessage); } else { if (coordinate.AccuracyLevel >= 0 && coordinate.AccuracyLevel <= 3) { throw new Exception(coordinate.AccuracyDescription); } } } else { throw new Exception("Request could not be processed"); } return coordinate; }
public HitTestResult(IHittable target, bool hit, Coordinates snapPoint, object data) { this.target = target; this.hit = hit; this.snapPoint = snapPoint; this.data = data; }
//Constructors: public TerrainTile(Vector3 vec, TerrainType type, Topper top) { terrainType = type; topper = top; var battlespud = f*g; Coordinates coords = new Coordinates (vec); }
public TerrainTile SetTerrainTile(Vector3 vec) { Coordinates coords = new Coordinates (vec); topper = Topper.Empty; terrainType = TerrainType.Stone; return this; }
/// <summary> /// Add blockage to partition /// </summary> /// <param name="partition"></param> /// <param name="c"></param> public void AddBlockage(IConnectAreaWaypoints partition, Coordinates c, bool acrossSegment) { partition.Blockage.BlockageExists = true; partition.Blockage.BlockageCoordinates = c; partition.Blockage.SecondsSinceObserved = 0.0; partition.Blockage.BlockageTimeCost = 1800; if (partition.Blockage.BlockageHasExisted) partition.Blockage.BlockageLifetime = partition.Blockage.BlockageLifetime * 4.0; if (acrossSegment && partition is ArbiterLanePartition) { foreach (ArbiterLanePartition alp in ((ArbiterLanePartition)partition).NonLaneAdjacentPartitions) { if (alp.IsInside(c)) { alp.Blockage.BlockageExists = true; alp.Blockage.BlockageCoordinates = c; alp.Blockage.SecondsSinceObserved = 0.0; alp.Blockage.BlockageTimeCost = 1800; if (alp.Blockage.BlockageHasExisted) alp.Blockage.BlockageLifetime = partition.Blockage.BlockageLifetime * 4.0; } } } // reset navigation costs this.currentTimes = new KeyValuePair<int, Dictionary<ArbiterWaypointId, DownstreamPointOfInterest>>(); }
public Block getBlockAt(Coordinates coordinates) { int x = (int)Math.Floor(coordinates.getX()); int y = (int)Math.Floor(coordinates.getY()); if(!blocks.ContainsKey(x.ToString() + "," + y.ToString())){ if (coordinates.getY() > -1) { blocks.Add(x.ToString() + "," + y.ToString(), new Block(new Air())); } else if (coordinates.getY() == -1) { blocks.Add(x.ToString() + "," + y.ToString(), new Block(new Grass())); } else if (coordinates.getY() == -2) { Random rnd = new Random(); if (rnd.Next(0, 2) == 0) { blocks.Add(x.ToString() + "," + y.ToString(), new Block(new Dirt())); } else { blocks.Add(x.ToString() + "," + y.ToString(), new Block(new Stone())); } } else if (coordinates.getY() < -2) { blocks.Add(x.ToString() + "," + y.ToString(), new Block(new Stone())); } blocks[x.ToString() + "," + y.ToString()].setCoordinates(coordinates); } return blocks[x.ToString() + "," + y.ToString()]; }
public void WhenACoordinateHasBeenExploredThenIsExploredIsTrue() { var minefield = Minefield.Empty(2, 3); var coordinate = new Coordinates(0, 1); var exploredMinefield = minefield.Explore(coordinate); Assert.AreEqual(true, exploredMinefield.IsExplored(coordinate.RowIndex, coordinate.ColumnIndex)); }
public WorldCell getCell(Coordinates cell_coords) { if (checkCoordinateIntegrity (cell_coords)) { return cells[cell_coords.x, cell_coords.y]; } return null; }
public LinePathSegment(Coordinates start, Coordinates end, double? endSpeed, bool? stopline) { this.start = start; this.end = end; this.endSpeed = endSpeed; this.stopline = stopline; }
public bool isEqual(Coordinates coordinate) { if(coordinate.x == x && coordinate.y == y) { return true; } return false; }
public JsonResult GetCoordinates(string street, string number) { var reguestGET = WebRequest.Create("http://nominatim.openstreetmap.org/search?q=" + number + "+" + street + ",+Донецк, Украина&format=xml&addressdetails=1"); reguestGET.Proxy = null; var webResponse = reguestGET.GetResponse(); var stream = webResponse.GetResponseStream(); if (stream == null) { throw new Exception("Can't get response from server."); } var xmlDoc = new XmlDocument(); xmlDoc.Load(stream); var tagPlace = (XmlElement) xmlDoc.GetElementsByTagName("place")[0]; if (tagPlace == null) { return Json(null, JsonRequestBehavior.AllowGet); } var lat = Convert.ToSingle(tagPlace.GetAttribute("lat"), new CultureInfo("en-US")); var lon = Convert.ToSingle(tagPlace.GetAttribute("lon"), new CultureInfo("en-US")); var coord = new Coordinates { Lat = lat, Lon = lon }; return Json(coord, JsonRequestBehavior.AllowGet); }
public LinePathSegment(Coordinates start, Coordinates end) { this.start = start; this.end = end; endSpeed = null; stopline = null; }
public ActionResult Coordinates_Destroy([DataSourceRequest]DataSourceRequest request, Coordinates coordinate) { var coordinateToDelete = this.coordinates.GetAll().Where(x => x.Id == coordinate.Id).FirstOrDefault(); this.coordinates.Delete(coordinateToDelete); return this.Json(new[] { coordinateToDelete }.ToDataSourceResult(request, this.ModelState)); }
public Coordinates MoveForward(Coordinates currentCoordinates) { return(new Coordinates(currentCoordinates.XCoordinate - 1, currentCoordinates.YCoordinate)); }
public override void ScrollBufferContents(Rectangle source, Coordinates destination, Rectangle clip, BufferCell fill) { }
public override void SetBufferContents(Coordinates origin, BufferCell[,] contents) { throw new NotImplementedException(); }
private bool IsCancelled(IEntityManager entityManager) { if (!entityManager.EntityExists(EventArgs.User) || EventArgs.Target is {} target&& !entityManager.EntityExists(target)) { return(true); } //https://github.com/tgstation/tgstation/blob/1aa293ea337283a0191140a878eeba319221e5df/code/__HELPERS/mobs.dm if (EventArgs.CancelToken.IsCancellationRequested) { return(true); } // TODO :Handle inertia in space. if (EventArgs.BreakOnUserMove && !entityManager.GetComponent <TransformComponent>(EventArgs.User).Coordinates.InRange( entityManager, UserGrid, EventArgs.MovementThreshold)) { return(true); } if (EventArgs.BreakOnTargetMove && !entityManager.GetComponent <TransformComponent>(EventArgs.Target !.Value).Coordinates.InRange( entityManager, TargetGrid, EventArgs.MovementThreshold)) { return(true); } if (EventArgs.BreakOnDamage && TookDamage) { return(true); } if (EventArgs.ExtraCheck != null && !EventArgs.ExtraCheck.Invoke()) { return(true); } if (EventArgs.BreakOnStun && entityManager.HasComponent <StunnedComponent>(EventArgs.User)) { return(true); } if (EventArgs.NeedHand) { if (!entityManager.TryGetComponent(EventArgs.User, out HandsComponent? handsComponent)) { // If we had a hand but no longer have it that's still a paddlin' if (_activeHand != null) { return(true); } } else { var currentActiveHand = handsComponent.ActiveHand; if (_activeHand != currentActiveHand) { return(true); } var currentItem = handsComponent.GetActiveHand; if (_activeItem != currentItem) { return(true); } } } return(false); }
public PlayerAssault(redd096.StateMachine stateMachine, Coordinates coordinates) : base(stateMachine, coordinates) { }
public virtual Coordinates CalculateCoordinates() => (from visit in Visits orderby visit.Visited where visit.Coordinates.IsSpecified select visit.Coordinates) .LastOrDefault() ?? Coordinates.Null();
void Output(Coordinates loc) { Debug.Log("World Location: " + loc.InWorld.X + " " + loc.InWorld.Y); Debug.Log("Chunk Location: " + loc.InChunks.X + " " + loc.InChunks.Y + " " + loc.InChunks.I + " " + loc.InChunks.J); Debug.Log("\n"); }
public Wall(Coordinates coordinates) : base(coordinates, '#') { }
public static void MoveTo(this Entity e, Coordinates coords, float speed) { }
// Checking for no change, so exact equality is fine public static bool HasChanged(Coordinates a, Coordinates b) { return(a.X != b.X || a.Y != b.Y || a.Z != b.Z); }
/// <summary> /// This API crops a region of the screen buffer. In this example /// this functionality is not needed so the method throws a /// NotImplementException exception. /// </summary> /// <param name="source">The region of the screen to be scrolled.</param> /// <param name="destination">The region of the screen to receive the /// source region contents.</param> /// <param name="clip">The region of the screen to include in the operation.</param> /// <param name="fill">The character and attributes to be used to fill all cell.</param> public override void ScrollBufferContents(Rectangle source, Coordinates destination, Rectangle clip, BufferCell fill) { throw new NotImplementedException(); }
public new IQueryable <ContentPage> GetQuery(string query, string scope, string language, Coordinates center, string site, out string indexName) { language = Context.Language.Name; return(base.GetQuery(query, scope, language, center, site, out indexName)); }
public static Vector3f ToSpatialVector3f(this Coordinates coordinates) { return(new Vector3f((float)coordinates.x, (float)coordinates.y, (float)coordinates.z)); }
public bool AddWorkableUnitToQueue(Type model, string name, Coordinates park, Coordinates work) { StorageFreeSlots = StorageCapacity - Storage.Count; // Storage slots left QueueFreeSlots = QueueCapacity - Queue.Count; // Queue slots left int freeSlotsLeft = StorageFreeSlots - Queue.Count; // Slots that can still be taken if ((StorageFreeSlots <= 0) || (QueueFreeSlots <= 0) || (freeSlotsLeft <= 0)) { FactoryProgress(this, new StatusChangedEventArgs("ERROR : No more free slots.")); return(false); } else { Queue.Add(new FactoryQueueElement(name, model, park, work)); FactoryProgress(Queue.First(), new StatusChangedEventArgs("New robot was added to Queue.")); tryBuild(); return(true); } }
public static void FindParkingInterval(IList <Obstacle> obstacles, LineSegment projectionLine, double offDistMax, double offDistMin, double maxBottomDist, double maxTopDist, ref Coordinates topPoint, ref Coordinates bottomPoint) { List <double> projectedDists = new List <double>(1000); Coordinates vec = projectionLine.UnitVector; Coordinates startPt = projectionLine.P0; double len = projectionLine.Length; foreach (Obstacle obs in obstacles) { foreach (Coordinates pt in obs.AvoidancePolygon) { double projDist = vec.Dot(pt - startPt); double offDist = vec.Cross(pt - startPt); if (projDist < 0 || projDist > len) { continue; } if (offDist < offDistMin || offDist > offDistMax) { continue; } // add to the list projectedDists.Add(projDist); } } // sort the list projectedDists.Sort(); // find the max dist between two adjacent projected distance double bestDist = -1; double bestProjBottom = 0; double bestProjTop = maxTopDist; for (int i = 0; i < projectedDists.Count - 1; i++) { if (projectedDists[i] > maxBottomDist) { if (bestDist < 0) { bestDist = bestProjTop = projectedDists[i]; } break; } double dist = projectedDists[i + 1] - projectedDists[i]; if (dist > bestDist) { bestDist = dist; bestProjBottom = projectedDists[i]; bestProjTop = projectedDists[i + 1]; } } bottomPoint = projectionLine.P0 + vec * bestProjBottom; topPoint = projectionLine.P0 + vec * bestProjTop; }
/// <summary> /// Valeur de la position de la pièce. /// </summary> /// <returns>La valeur.</returns> /// <param name="king">Coordonnées du roi ennemi.</param> /// <param name="board">Tableau de jeu.</param> public override int positionValue(Coordinates king, Board board) { return(positionValueGoldPattern(king)); }
public int setNextWaypoint(Coordinates pto) { nextCoordinates = pto; return(0); }
// obstacles - list of obstacles to avoid near the parking spot // projectionLine - P1 is the place where the front bumper of the vehicle should end up; P0 is where the rear bumper of the vehicle should end up // zonePerimiter - list of points specifying the perimiter of the parking zone // vehiclePosition - current position of the vehicle // vehicleHeading - heading of the car, in radians // corner1 and corner2 are always set to the corners of the rectangle, however if the function returns FALSE then // the rectangle is the minimum 8x8 box containing the vehicle's back axis whether or not the box contains obstacles or crosses the zone perimiter public static bool FindParkingInterval(IList <Obstacle> obstacles, LineSegment projectionLine, Polygon zonePerimeter, Coordinates vehiclePosition, double vehicleHeading, ref Coordinates[] corners) { const double expansion_step = .25; bool ret = true; // transform everything into "parking coordinates": // 0,0 is where the center of the rear bumper should end up when parking is finished // the vehicle should be parallel to (and on top of) the Y axis when parking has finished (positive Y) List <Polygon> pcObstacles = new List <Polygon>(obstacles.Count); for (int i = 0; i < obstacles.Count; i++) { Polygon p = obstacles[i].AvoidancePolygon.Inflate(Math.Max(obstacles[i].minSpacing, .5)); for (int j = 0; j < p.points.Count; j++) { p.points[j] -= projectionLine.P0; p.points[j] = p.points[j].Rotate(-projectionLine.UnitVector.RotateM90().ArcTan); } pcObstacles.Add(p); } Polygon pcPerimeter = new Polygon(zonePerimeter); for (int i = 0; i < pcPerimeter.points.Count; i++) { pcPerimeter.points[i] -= projectionLine.P0; pcPerimeter.points[i] = pcPerimeter.points[i].Rotate(-projectionLine.UnitVector.RotateM90().ArcTan); } Coordinates pcVehPos = vehiclePosition; pcVehPos -= projectionLine.P0; pcVehPos = pcVehPos.Rotate(-projectionLine.UnitVector.RotateM90().ArcTan); double leftBound, rightBound; double lowBound; // highbound is always 0 const double highBound = 0; leftBound = Math.Min(-TahoeParams.T / 2.0 - 1, pcVehPos.X - TahoeParams.T / 2.0 * 1.2); rightBound = Math.Max(TahoeParams.T / 2.0 + 1, pcVehPos.X + TahoeParams.T / 2.0 * 1.2); lowBound = Math.Min(0, pcVehPos.Y - TahoeParams.T / 2.0 * 1.2); bool canExpandDown = true; bool canExpandLeft = true; bool canExpandRight = true; // initial expansion... lower boundary while (lowBound > -8 && canExpandDown) { LineSegment l = new LineSegment(new Coordinates(leftBound, lowBound), new Coordinates(rightBound, lowBound)); if (ExpansionViolatesConstraints(l, pcPerimeter, pcObstacles)) { canExpandDown = false; break; } lowBound -= expansion_step; } // initial expansion... left & right boundary while ((rightBound - leftBound) < 8 && (canExpandRight || canExpandLeft)) { LineSegment ls; ls = new LineSegment(new Coordinates(leftBound, lowBound), new Coordinates(leftBound, highBound)); if (ExpansionViolatesConstraints(ls, pcPerimeter, pcObstacles)) { canExpandLeft = false; } else { leftBound -= expansion_step; } ls = new LineSegment(new Coordinates(rightBound, lowBound), new Coordinates(rightBound, highBound)); if (ExpansionViolatesConstraints(ls, pcPerimeter, pcObstacles)) { canExpandRight = false; } else { rightBound += expansion_step; } } // move boundaries out to make at least an 8x8 m box, even if this violates the perimiter/includes obstacles if (rightBound - leftBound < 8) { double tmp = (rightBound + leftBound) / 2; leftBound = tmp - 4; rightBound = tmp + 4; ret = false; } if (lowBound > -8) { ret = false; lowBound = -8; } bool lastExpandLeft = false; while ((canExpandDown || canExpandLeft || canExpandRight) && (lowBound > -30) && (rightBound - leftBound) < 30) { if (!(canExpandLeft || canExpandRight) || (-lowBound < (rightBound - leftBound) && canExpandDown)) { LineSegment l = new LineSegment(new Coordinates(leftBound, lowBound - .5), new Coordinates(rightBound, lowBound - .5)); if (ExpansionViolatesConstraints(l, pcPerimeter, pcObstacles)) { canExpandDown = false; } else { lowBound -= expansion_step; } } else if (!(canExpandDown || canExpandRight) || (canExpandLeft && !(lastExpandLeft && canExpandRight))) { LineSegment l = new LineSegment(new Coordinates(leftBound - .5, lowBound), new Coordinates(leftBound - .5, highBound)); if (ExpansionViolatesConstraints(l, pcPerimeter, pcObstacles)) { canExpandLeft = false; } else { leftBound -= expansion_step; } lastExpandLeft = true; } else // canExpandRight { LineSegment l = new LineSegment(new Coordinates(rightBound + .5, lowBound), new Coordinates(rightBound + .5, highBound)); if (ExpansionViolatesConstraints(l, pcPerimeter, pcObstacles)) { canExpandRight = false; } else { rightBound += expansion_step; } lastExpandLeft = false; } } corners = new Coordinates[4]; corners[0] = new Coordinates(leftBound, lowBound); corners[1] = new Coordinates(leftBound, highBound); corners[2] = new Coordinates(rightBound, highBound); corners[3] = new Coordinates(rightBound, lowBound); Random r = new Random(); for (int i = 0; i < 4; i++) { corners[i] = corners[i].Rotate(projectionLine.UnitVector.RotateM90().ArcTan); corners[i] += projectionLine.P0; } return(ret); /*Line pll = new Line(projectionLine.P0,projectionLine.P1); * Coordinates offVec = projectionLine.UnitVector.Rotate90(); * // find the leftmost boundary (looking into the parking spot) * for (int i = 0; i < 20; i++) * { * Line tl = new Line(pll); * tl.P0 = tl.P0 + offVec * i; * tl.P1 = tl.P1 + offVec * i; * * Coordinates[] ipts; * zonePerimeter.Intersect(tl, out ipts); * * obstacles[0].AvoidancePolygon * * if (ipts.Length < 2) break; // the test line is completely outside of the zone perimiter * if (ipts.Length == 2) * { * * } * }*/ }
public MonsterCard(Coordinates coords, int manaCost, string name, string description, int damage, int hitPoints) : base(coords, manaCost, name, description) { this.Damage = damage; this.HitPoints = hitPoints; }
public float setHomeWaypoint(Coordinates pto) { homeCoordinates = pto; return(0); }
public AbsolutePose(Coordinates xy, double heading, CarTimestamp timestamp) { this.xy = xy; this.heading = heading; this.timestamp = timestamp; }
public int doNavigation(int waypointRadius) { busyNavigation = true; float maxDroneSpeedToDestination = 0.5f; float maxDroneSpeedRotation = 0.01f; float angleToWaypoint = 0; currCoordinates = new Coordinates(mDrone.iDroneCup_Read_Longitude(), mDrone.iDroneCup_Read_Latitude()); // DEGUB // //currCoordinates.latitude = 41.536955; //currCoordinates.longitude = -8.627266; //homeCoordinates = currCoordinates; // DEGUB // // Check: is out of range? in wrong direction? dist2waypoint = calculateDistance(currCoordinates, homeCoordinates); if (dist2waypoint > SAFE_GPS_RANGE) { this.runNavigation = false; mDrone.iDroneCup_Hover(); mDrone.iDroneCup_Land(); System.Threading.Thread.Sleep(10); System.Diagnostics.Debug.WriteLine("doNavigation -> Check: is out of range? : " + dist2waypoint.ToString()); } // Check: is at waypoint? else if (isAtWaypoint(waypointRadius)) { // Disable navigation OR do something else: Next waypoint? Action? Land? this.runNavigation = false; mDrone.iDroneCup_Hover(); System.Threading.Thread.Sleep(10); System.Diagnostics.Debug.WriteLine("doNavigation -> Check: is at waypoint?"); } // Action: Navigation else { // Read Drone Heading float trueNorthHeading = mDrone.iDroneCup_Read_Heading(0); droneHeading = trueNorthHeading; // Check: Rotation Error float bearing = calculateBearing(currCoordinates, nextCoordinates); float angleDiff = bearing - trueNorthHeading; angleToWaypoint = (float)(Math.Atan2(Math.Sin(angleDiff * DEG2RAD), Math.Cos(angleDiff * DEG2RAD)) * RAD2DEG); droneBearing = bearing; // Check: Distance Error float distanceToWaypoint = calculateDistance(currCoordinates, nextCoordinates); // Compute: Rotation Correction float yawSpeedDesired = angleToWaypoint * maxDroneSpeedRotation; yawSpeedDesired = KeepInRange(yawSpeedDesired, -0.25f, 0.25f); // Compute: Motion Correction float tmpsin = (float)Math.Sin(angleToWaypoint * DEG2RAD); float tmpcos = (float)Math.Cos(angleToWaypoint * DEG2RAD); float pitchSpeedDesired = (maxDroneSpeedToDestination * tmpcos); float rollSpeedDesired = (maxDroneSpeedToDestination * tmpsin); rollSpeedDesired = KeepInRange(rollSpeedDesired, -0.25f, 0.25f); pitchSpeedDesired = KeepInRange(pitchSpeedDesired, -0.25f, 0.25f); // Optional: Initial yaw correction if (angleToWaypoint > 40.0f || angleToWaypoint < -40.0f) { // Apply only Rotation Correction //mDrone.iDroneCup_MoveAdvanced(0,0,0,yawSpeedDesired); } else { // Apply Global Correction //mDrone.iDroneCup_MoveAdvanced(pitchSpeedDesired,rollSpeedDesired,0,yawSpeedDesired); } } // DEBUG // float tickDiff = System.Environment.TickCount - lastTick; lastTick = System.Environment.TickCount; fps = (int)Math.Round(1000.0f / tickDiff); System.Diagnostics.Debug.WriteLine("doNavigation -> Navigation done... " + "FPS: " + fps.ToString() + "angle: " + angleToWaypoint.ToString()); // DEBUG // busyNavigation = false; return(0); }
public void Setup() { _coordinates = new Coordinates(x, y); }
public void ReportOponentsLastShotResult(Coordinates coordinates, ShotResult result) { }
public int GetHeightAt(Coordinates coords) { return(_grid[coords.Y, coords.X]); }
IEnumerator SonarWave(Coordinates userCoords) { Captas4Feedback waveFeedback = feedbackBehavior as Captas4Feedback; Coordinates detectableCoords; float distance; float waveRange = 0; float waveTime = 0; float padding = 0; //If Captas4 is set on global mode, deffine range of Captas4 to the distance with the farthest map angle if (!partialMode) { float tempDistance = 0; range = 0; foreach (Vector2 anglePos in mapAnglesPos) { tempDistance = Mathf.Abs(Vector2.Distance(userCoords.position, anglePos)); if (tempDistance > range) { range = tempDistance; } } } waveFeedback.StartWave(range, waveDuration); while (waveTime < waveDuration) { //looping through all detectable on the map foreach (DetectableOceanEntity detectable in levelManager.submarineEntitiesInScene) { detectableCoords = new Coordinates(detectable.transform.position, Vector2.zero, 0f); distance = Mathf.Abs(Vector2.Distance(userCoords.position, detectableCoords.position)); //if current tested detectable is in range place a point on his pos //there is a security (padding) if object pos is at a position beetween two tested distance increasing at each frame (depend on the progression of the timer) if (distance <= waveRange && distance >= waveRange + padding) { if (availableDetectionPoints.Count > 0) { availableDetectionPoints[0].ActivatePoint(detectable, pointFadeDuration, this); usedDetectionPoints.Add(availableDetectionPoints[0]); availableDetectionPoints.RemoveAt(0); } else { Debug.Log("Not Enough object in pool"); } } } waveTime += Time.deltaTime; padding = waveRange - (range * (waveTime / waveDuration)); waveRange = range * (waveTime / waveDuration); yield return(new WaitForFixedUpdate()); } readyToUse = true; }
public bool IsCheckmate(ChessPiece king) { List <ChessPiece> dangers = new List <ChessPiece>(); List <Coordinates> allMoves = new List <Coordinates>(); ChessPiece ownKing; Coordinates kingLoc; foreach (ChessPiece piece in pieceLocations) { if ((piece != null) && (piece.gameObject.tag == king.gameObject.tag)) { allMoves.AddRange(piece.GetMoves(false)); } } if (king.gameObject.tag == "Team1") { ownKing = team1_king; } else { ownKing = team2_king; } kingLoc = new Coordinates(ownKing.currentPos.x, ownKing.currentPos.z); dangers = ownKing.isCheck(ownKing.currentPos); if (dangers.Count != 0) { List <ChessPiece> tempDangers = new List <ChessPiece>(dangers); foreach (ChessPiece badPiece in tempDangers) { foreach (Coordinates move in allMoves) { if (move == badPiece.currentPos) { dangers.Remove(badPiece); continue; } } if (badPiece is Rook || badPiece is Queen) { if (kingLoc.x == badPiece.currentPos.x) { if (kingLoc.z > badPiece.currentPos.z) { for (int i = kingLoc.z - 1; i > badPiece.currentPos.z; i--) { foreach (Coordinates move in allMoves) { if (move == badPiece.currentPos) { dangers.Remove(badPiece); continue; } } } } else { for (int i = kingLoc.z + 1; i < badPiece.currentPos.z; i++) { foreach (Coordinates move in allMoves) { if (move == badPiece.currentPos) { dangers.Remove(badPiece); continue; } } } } } else { if (kingLoc.x > badPiece.currentPos.x) { for (int i = kingLoc.x - 1; i > badPiece.currentPos.x; i--) { foreach (Coordinates move in allMoves) { if (move == badPiece.currentPos) { dangers.Remove(badPiece); continue; } } } } else { for (int i = kingLoc.x + 1; i < badPiece.currentPos.x; i++) { foreach (Coordinates move in allMoves) { if (move == badPiece.currentPos) { dangers.Remove(badPiece); continue; } } } } } } if (badPiece is Bishop || badPiece is Queen) { if (kingLoc.x - badPiece.currentPos.x > 0) { if (kingLoc.z - badPiece.currentPos.z > 0) { int j = kingLoc.z - 1; for (int i = kingLoc.x - 1; i < badPiece.currentPos.x; i++, j++) { foreach (Coordinates move in allMoves) { if (move == badPiece.currentPos) { dangers.Remove(badPiece); continue; } } } } else { int j = kingLoc.z + 1; for (int i = kingLoc.x - 1; i < badPiece.currentPos.x; i++, j--) { foreach (Coordinates move in allMoves) { if (move == badPiece.currentPos) { dangers.Remove(badPiece); continue; } } } } } else { if (kingLoc.z - badPiece.currentPos.z > 0) { int j = kingLoc.z - 1; for (int i = kingLoc.x + 1; i > badPiece.currentPos.x; i--, j++) { foreach (Coordinates move in allMoves) { if (move == badPiece.currentPos) { dangers.Remove(badPiece); continue; } } } } else { int j = kingLoc.z + 1; for (int i = kingLoc.x + 1; i > badPiece.currentPos.x; i--, j--) { foreach (Coordinates move in allMoves) { if (move == badPiece.currentPos) { dangers.Remove(badPiece); continue; } } } } } } } } bool saveFlag = false; if (dangers.Count != 0) { for (int x = -1; x <= 1; x++) { for (int z = -1; z <= 1; z++) { Coordinates tempCoord = new Coordinates(x, z); if (ownKing.isCheck(kingLoc + tempCoord).Count == 0) { saveFlag = true; } } } } return(dangers.Count != 0 && !saveFlag); }
private static Action DecideActionToTake(List <Action> actions) { Action bestAction = null; List <Action> moveActions = actions.Where(a => a.Type == MoveAndBuild).ToList(); List <Action> pushActions = actions.Where(a => a.Type == PushAndBuild).ToList(); int maxMoveHeight = -1; int maxBuildHeight = -1; bool ignoredBuildToFour = false; Action ignoredAction = null; //TODO - make this a set an then optimise!! For example you might choose one that traps you //when you could actually escape to a whole load of 3s bool ignoreBuildTooBig = false; HashSet <Action> ignoredBuildTooBigActions = new HashSet <Action>(); foreach (Action action in moveActions) { Unit theUnit = MyUnits[action.Index]; Coordinates unitCo = new Coordinates(theUnit.X, theUnit.Y); Coordinates moveCo = unitCo.GetCoordinateInDirection(action.MoveDirection); int heightOfMoveSquare = TheGrid.GetHeightAt(moveCo.X, moveCo.Y); Coordinates buildCo = moveCo.GetCoordinateInDirection(action.BuildDirection); int heightOfBuildSquareAfterBuild = TheGrid.GetHeightAt(buildCo.X, buildCo.Y) + 1; //the unit that can perform this action if (heightOfMoveSquare == 3) { //we're done, move to that square if ((theUnit.Height == 3 || theUnit.Height == 2) && heightOfBuildSquareAfterBuild == 4) { DebugWriteLine("Setting ignore build to 4 true"); ignoredBuildToFour = true; ignoredAction = action; //don't build on our own threes continue; } if (heightOfBuildSquareAfterBuild == 3 && EnemyCanReachCoordinatesAtHeight(buildCo, heightOfBuildSquareAfterBuild)) { //don't give enemy a point continue; } //if we get here then we're getting on a 3 without having to build to 4 - don't overwrite this //with a worse "3 and build to 4" move ignoredBuildToFour = false; bestAction = action; break; } else { if (heightOfBuildSquareAfterBuild > heightOfMoveSquare + 1) { ignoreBuildTooBig = true; ignoredBuildTooBigActions.Add(action); //why build something that we can't move to? continue; } if (heightOfBuildSquareAfterBuild == 3 && EnemyCanReachCoordinatesAtHeight(buildCo, heightOfBuildSquareAfterBuild)) { //don't give enemy a point continue; } if (maxMoveHeight < heightOfMoveSquare) { maxMoveHeight = heightOfMoveSquare; maxBuildHeight = heightOfBuildSquareAfterBuild; bestAction = action; } else if (maxMoveHeight == heightOfMoveSquare) { //same move height, check build height if (maxBuildHeight < heightOfBuildSquareAfterBuild) { maxMoveHeight = heightOfMoveSquare; maxBuildHeight = heightOfBuildSquareAfterBuild; bestAction = action; } } } } //certain cases just push as not enough to gain by moving foreach (Action action in pushActions) { Unit theUnit = MyUnits[action.Index]; Coordinates unitCo = new Coordinates(theUnit.X, theUnit.Y); Coordinates enemyCoords = unitCo.GetCoordinateInDirection(action.MoveDirection); Unit enemyUnit = EnemyUnits.First(e => e.Coords.Equals(enemyCoords)); Coordinates enemyFinalLocation = enemyCoords.GetCoordinateInDirection(action.BuildDirection); if (theUnit.Height == 0 || theUnit.Height == 1) { //we're low down if (enemyUnit.Height >= 2 && TheGrid.GetHeightAt(enemyFinalLocation) < 2) { //knock them off if (TheGrid.GetHeightAt(enemyFinalLocation) == 0) { //knock them straight to ground bestAction = action; break; } else { Action betterAction = GetBetterPushActionIfPossible(actions, enemyFinalLocation); bestAction = betterAction ?? action; break; } } } else { //how good is the best action move? if (bestAction == null) { DebugWriteLine("Best action is null"); continue; } Unit ourBestUnit = MyUnits[bestAction.Index]; Coordinates bestUnitCo = new Coordinates(ourBestUnit.X, ourBestUnit.Y); Coordinates bestMoveCo = bestUnitCo.GetCoordinateInDirection(bestAction.MoveDirection); DebugWriteLine($"About to get height with ({bestMoveCo.X}, {bestMoveCo.Y})"); int heightOfMoveSquare = TheGrid.GetHeightAt(bestMoveCo.X, bestMoveCo.Y); DebugWriteLine($"Height of move square is {heightOfMoveSquare}"); if (heightOfMoveSquare == 0 || heightOfMoveSquare == 1) { //we're high, but have to go all the way down... see if we can hurt them at least a bit if (enemyUnit.Height >= 2 && TheGrid.GetHeightAt(enemyFinalLocation) < 2) { //knock them off if (TheGrid.GetHeightAt(enemyFinalLocation) == 0) { //knock them straight to ground bestAction = action; break; } else { Action betterAction = GetBetterPushActionIfPossible(actions, enemyFinalLocation); bestAction = betterAction ?? action; break; } } } else if (heightOfMoveSquare == 3) { //so I'm on a high square, but I want to see if I can knock them down to 0 //there are often groups of 3 squares which we can remove them from so they can't get back on if (enemyUnit.Height == 3 && TheGrid.GetHeightAt(enemyFinalLocation) < 2) { //knock them off if (TheGrid.GetHeightAt(enemyFinalLocation) == 0) { //knock them straight to ground bestAction = action; break; } else { Action betterAction = GetBetterPushActionIfPossible(actions, enemyFinalLocation); bestAction = betterAction ?? action; break; } } } } } if (ignoredBuildToFour) { DebugWriteLine("Inside ignored build to four"); if (bestAction == null) { DebugWriteLine("USING IGNORED ACTION"); bestAction = ignoredAction; } else if (bestAction.Type == MoveAndBuild) { DebugWriteLine("Action type check"); Unit theUnit = MyUnits[bestAction.Index]; Coordinates unitCo = new Coordinates(theUnit.X, theUnit.Y); Coordinates moveCo = unitCo.GetCoordinateInDirection(bestAction.MoveDirection); int heightOfMoveSquare = TheGrid.GetHeightAt(moveCo.X, moveCo.Y); Coordinates buildCo = moveCo.GetCoordinateInDirection(bestAction.BuildDirection); int heightOfBuildSquareAfterBuild = TheGrid.GetHeightAt(buildCo.X, buildCo.Y) + 1; if (heightOfMoveSquare < 2 && heightOfBuildSquareAfterBuild <= 2) { //note we know height will be four so don't worry about giving enemy a point case //moving down and not building particularly tall, worth taking ignored action bestAction = ignoredAction; DebugWriteLine("USING IGNORED ACTION"); } } } if (bestAction == null) { if (ignoreBuildTooBig) { //nothing chosen, really struggling for options - try to build on a 4 //for now just take first one bestAction = ignoredBuildTooBigActions.First(); DebugWriteLine("Using ignored action for building too big"); //foreach (Action action in ignoredBuildTooBigActions) //{ // bestAction = action; // break; //} } } return(bestAction); }
public static void RemovePieceAt(Coordinates pos) { pieceLocations[pos.x, pos.z] = null; }
public override void InteracteOn(Entity user, Coordinates pos) { Action.Invoke(user, pos); }