/// <summary> /// Gets a <see cref="Rectangle"/> that represents the valid area that items can be picked up at from /// the given <paramref name="spatial"/>. /// </summary> /// <param name="spatial">The <see cref="ISpatial"/> doing the picking-up.</param> /// <returns>A <see cref="Rectangle"/> that represents the area region that items can be picked up at from /// the given <paramref name="spatial"/>.</returns> public static Rectangle GetPickupArea(ISpatial spatial) { const int padding = 70; var r = spatial.ToRectangle(); return(new Rectangle(r.X - padding, r.Y - padding, r.Width + (padding * 2), r.Height + (padding * 2))); }
public Ray2D(ISpatial character, Vector2 position, Vector2 direction, ISpatialCollection collection) { Position = position; Direction = direction; _mapSpatialCollection = collection; _owner = character; }
/// <summary> /// Handles when a <see cref="ISpatial"/> in this <see cref="ISpatialCollection"/> resizes. /// </summary> /// <param name="sender">The <see cref="ISpatial"/> that resized.</param> /// <param name="e">The <see cref="EventArgs{Vector2}"/> instance containing the event data.</param> void Spatial_Resized(ISpatial sender, EventArgs <Vector2> e) { // Get the grid index for the last and current max positions to see if the segments have changed var maxSegment = WorldPositionToGridSegment(sender.Position + sender.Size); var oldMaxSegment = WorldPositionToGridSegment(sender.Position + e.Item1); if (maxSegment == oldMaxSegment) { return; } // FUTURE: Can improve performance by only removing from and adding to the appropriate changed segments // The position did change, so we have to remove the spatial from the old segments and add to the new var startIndex = WorldPositionToGridSegment(sender.Position); var length = WorldPositionToGridSegment(sender.Position + e.Item1); foreach (var segment in GetSegments(startIndex, length)) { segment.Remove(sender); } Debug.Assert(!CollectionContains(sender), "spatial was not completely removed from the grid!"); // Add the spatial back using the new positions foreach (var segment in GetSegments(sender)) { segment.Add(sender); } }
/// <summary> /// Checks if the <see cref="ISpatial"/> contains a point. /// </summary> /// <param name="spatial">The spatial.</param> /// <param name="p">Point to check if the <paramref name="spatial"/> contains.</param> /// <returns>True if the <paramref name="spatial"/> contains <paramref name="p"/>; otherwise false.</returns> public static bool Contains(this ISpatial spatial, Vector2 p) { var min = spatial.Position; var max = spatial.Max; return(min.X <= p.X && max.X >= p.X && min.Y <= p.Y && max.Y >= p.Y); }
/// <summary> /// Plays the sound for an <see cref="ActionDisplay"/> in a very basic way. /// This is intended to be called by the scripts for playing sound instead of handling sound manually. /// </summary> /// <param name="actionDisplay">The <see cref="ActionDisplay"/>.</param> /// <param name="source">The source of the sound.</param> static void PlaySoundSimple(ActionDisplay actionDisplay, ISpatial source) { // Check for valid parameters if (actionDisplay == null) { Debug.Fail("actionDisplay must not be null."); return; } if (source == null) { Debug.Fail("source must not be null."); return; } // Make sure there is a valid sound if (!actionDisplay.Sound.HasValue) { return; } // When possible, attach the sound to the source. Otherwise, just play it where the source is currently at var attackerAsAudioEmitter = source as IAudioEmitter; if (attackerAsAudioEmitter != null) { _audioManager.SoundManager.Play(actionDisplay.Sound.Value, attackerAsAudioEmitter); } else { _audioManager.SoundManager.Play(actionDisplay.Sound.Value, source.Center); } }
public override IDictionary <string, object> Write(ISpatial value) { GeoJsonObjectWriter writer = new GeoJsonObjectWriter(); value.SendTo(new ForwardingSegment((SpatialPipeline)writer)); return(writer.JsonObject); }
/// <summary> /// Creates a <see cref="Rectangle"/> describing the area of a <see cref="ISpatial"/>. /// </summary> /// <param name="spatial">The <see cref="ISpatial"/> to get the <see cref="Rectangle"/> for.</param> /// <returns>A <see cref="Rectangle"/> describing the area of a <see cref="ISpatial"/>.</returns> public static Rectangle ToRectangle(ISpatial spatial) { Vector2 pos = spatial.Position; Vector2 size = spatial.Size; return(new Rectangle(pos.X, pos.Y, size.X, size.Y)); }
/// <summary> /// Gets the world position and rotation for this spatial object. /// The result has the same LocalAABB, i.e. it is not inherited. /// The result will have no parent. /// </summary> public static SpatialData GetWorldSpatialData(this ISpatial self) { Vector2 position = Vector2.Zero; float radians = 0.0f; ISpatial parent = self; while (parent != null) { SpatialData spatial = parent.Spatial; position += spatial.Position; radians += spatial.Rotation.Radians; Debug.Assert(spatial.Parent != parent); parent = spatial.Parent; } SpatialData result = new SpatialData { Position = position, Rotation = new Angle { Radians = radians }, LocalAABB = self.Spatial.LocalAABB, }; return(result); }
private ISpatial ReadSpatialValue(IEdmPrimitiveTypeReference expectedValueTypeReference, bool validateNullValue) { ODataVersionChecker.CheckSpatialValue(base.Version); if (this.TryReadNullValue(expectedValueTypeReference, validateNullValue)) { return(null); } ISpatial spatial = null; if (base.JsonReader.NodeType == JsonNodeType.StartObject) { IDictionary <string, object> source = this.ReadObjectValue(base.JsonReader); GeoJsonObjectFormatter formatter = SpatialImplementation.CurrentImplementation.CreateGeoJsonObjectFormatter(); if (expectedValueTypeReference.IsGeographyType()) { spatial = formatter.Read <Geography>(source); } else { spatial = formatter.Read <Geometry>(source); } } if (spatial == null) { throw new ODataException(Microsoft.Data.OData.Strings.ODataJsonPropertyAndValueDeserializer_CannotReadSpatialPropertyValue); } return(spatial); }
/// <summary> /// Find point-normal frame at ray-intersection point on mesh, or return false if no hit. /// Returns interpolated vertex-normal frame if available, otherwise tri-normal frame. /// </summary> public static bool RayHitPointFrame(DMesh3 mesh, ISpatial spatial, Ray3d ray, out Frame3f hitPosFrame, bool bForceFaceNormal = false) { hitPosFrame = new Frame3f(); int tid = spatial.FindNearestHitTriangle(ray); if (tid == DMesh3.InvalidID) { return(false); } var isect = TriangleIntersection(mesh, tid, ray); if (isect.Result != IntersectionResult.Intersects) { return(false); } Vector3d surfPt = ray.PointAt(isect.RayParameter); if (mesh.HasVertexNormals && bForceFaceNormal == false) { hitPosFrame = SurfaceFrame(mesh, tid, surfPt); // TODO isect has bary-coords already!! } else { hitPosFrame = new Frame3f(surfPt, mesh.GetTriNormal(tid)); } return(true); }
/// <summary> /// Gets if an <see cref="ISpatial"/> and <see cref="Rectangle"/> occupy any common space. /// </summary> /// <param name="a">The <see cref="ISpatial"/>.</param> /// <param name="b">The <see cref="Rectangle"/>.</param> /// <returns>True if the two occupy any common space; otherwise false.</returns> public static bool Intersects(this ISpatial a, Rectangle b) { bool ret; a.ToRectangle().Intersects(ref b, out ret); return(ret); }
/// <summary> /// Gets the new size to give an <see cref="ISpatial"/>. /// </summary> /// <param name="spatial">The <see cref="ISpatial"/>.</param> /// <param name="forceAlign">When true, aligning to the grid will be forced.</param> /// <returns>The new size for the <paramref name="spatial"/>.</returns> /// <exception cref="ArgumentNullException"><paramref name="spatial"/> is null.</exception> public Vector2 Resize(ISpatial spatial, bool forceAlign = false) { if (spatial == null) { throw new ArgumentNullException("spatial"); } if (!WillAlign && !forceAlign) { return(spatial.Size); } var s = Align(spatial.Max, forceAlign) - spatial.Position; if (s.X < GridSize.X) { s.X = GridSize.X; } if (s.Y < GridSize.Y) { s.Y = GridSize.Y; } return(s); }
public static void AttachTo(this ISpatial self, ISpatial newParent) { if (newParent != self) { self.Spatial.Parent = newParent; } }
public void CopyFrom(SpatialData other) { Parent = other.Parent; Position = other.Position; Rotation = other.Rotation; LocalAABB = other.LocalAABB; }
/// <summary> /// Fits an <see cref="ISpatial"/> into the grid so that all sides are snapped to the grid. /// The <paramref name="spatial"/> must support both <see cref="ISpatial.SupportsMove"/> and /// <see cref="ISpatial.SupportsResize"/>. /// </summary> /// <param name="forceAlign">When true, aligning to the grid will be forced.</param> /// <param name="spatial">The <see cref="ISpatial"/>.</param> public void Fit(ISpatial spatial, bool forceAlign = false) { if (spatial == null) { return; } if (!WillAlign && !forceAlign) { return; } if (!spatial.SupportsMove || !spatial.SupportsResize) { return; } var pos = Align(spatial, forceAlign); if (!spatial.TryMove(pos)) { return; } var size = Resize(spatial, forceAlign); spatial.TryResize(size); }
/// <summary> /// Aligns an <see cref="ISpatial"/>'s position to the grid. /// </summary> /// <param name="spatial">The <see cref="ISpatial"/>.</param> /// <param name="forceAlign">When true, aligning to the grid will be forced.</param> /// <returns>The position for the <paramref name="spatial"/>.</returns> /// <exception cref="ArgumentNullException"><paramref name="spatial"/> is null.</exception> public Vector2 Align(ISpatial spatial, bool forceAlign = false) { if (spatial == null) throw new ArgumentNullException("spatial"); return Align(spatial.Position, forceAlign); }
public virtual void Update() { base.begin_update(); int start_timestamp = this.CurrentInputTimestamp; if (MeshSource == null) { throw new Exception("GenerateClosedMeshOp: must set valid MeshSource to compute!"); } try { DMesh3 inputmesh = MeshSource.GetDMeshUnsafe(); ISpatial inputSpatial = MeshSource.HasSpatial ? MeshSource.GetSpatial() : null; DMeshAABBTree3 spatial = (inputSpatial != null && inputSpatial is DMeshAABBTree3) ? inputSpatial as DMeshAABBTree3 : get_cached_spatial(inputmesh); DMesh3 meshIn = new DMesh3(inputmesh); MeshRepairOrientation repair = new MeshRepairOrientation(meshIn, spatial); repair.OrientComponents(); repair.SolveGlobalOrientation(); if (invert_result) { meshIn.ReverseOrientation(true); } ResultMesh = meshIn; base.complete_update(); } catch (Exception e) { PostOnOperatorException(e); ResultMesh = base.make_failure_output(MeshSource.GetDMeshUnsafe()); base.complete_update(); } }
/// <summary> /// Handles when a <see cref="ISpatial"/> in this <see cref="ISpatialCollection"/> resizes. /// </summary> /// <param name="sender">The <see cref="ISpatial"/> that resized.</param> /// <param name="e">The <see cref="EventArgs{Vector2}"/> instance containing the event data.</param> void Spatial_Resized(ISpatial sender, EventArgs <Vector2> e) { // Get the grid index for the last and current max positions to see if the segments have changed var maxSegment = WorldPositionToGridSegment(sender.Position + sender.Size); var oldMaxSegment = WorldPositionToGridSegment(sender.Position + e.Item1); if (maxSegment == oldMaxSegment) { return; } // The position did change, so we have to remove the spatial from the old segments and add to the new var min = WorldPositionToGridSegment(sender.Position); var max = WorldPositionToGridSegment(sender.Position + e.Item1); var length = new Point(max.X - min.X, max.Y - min.Y); foreach (var segment in GetSegments(min, length)) { segment.Remove(sender); } Debug.Assert(!_gridSegments.Any(x => x.Contains(sender)), "spatial was not completely removed from the grid!"); // Add the spatial back using the new positions foreach (var segment in GetSegments(sender)) { segment.Add(sender); } }
/// <summary> /// Handles when a <see cref="ISpatial"/> in this <see cref="ISpatialCollection"/> moves. /// </summary> /// <param name="sender">The <see cref="ISpatial"/> that moved.</param> /// <param name="e">The <see cref="EventArgs{Vector2}"/> instance containing the event data.</param> void Spatial_Moved(ISpatial sender, EventArgs <Vector2> e) { // Get the grid index for the last and current positions to see if the segments have changed var minSegment = WorldPositionToGridSegment(sender.Position); var maxSegment = WorldPositionToGridSegment(sender.Max); var oldMinSegment = WorldPositionToGridSegment(e.Item1); var oldMaxSegment = WorldPositionToGridSegment(e.Item1 + sender.Size); if (minSegment == oldMinSegment && maxSegment == oldMaxSegment) { return; } // The position did change, so remove the ISpatial from all segments foreach (var segment in GetSegments(sender, e.Item1)) { segment.Remove(sender); } Debug.Assert(!_gridSegments.Any(x => x.Contains(sender)), "spatial was not completely removed from the grid!"); // Add the spatial back using the new positions foreach (var segment in GetSegments(sender)) { segment.Add(sender); } }
/// <summary> /// Gets a <see cref="Rectangle"/> that represents the area that represents where this <see cref="ISpatial"/> /// is standing. /// </summary> /// <param name="spatial">The <see cref="ISpatial"/>.</param> /// <returns>A <see cref="Rectangle"/> that represents the area that represents where this <see cref="ISpatial"/> /// is standing.</returns> public static Rectangle GetStandingAreaRect(this ISpatial spatial) { Vector2 min = spatial.Position; Vector2 size = spatial.Size; Rectangle r = new Rectangle(min.X + 1, min.Y + size.Y - 1, size.X - 2, 2); return(r); }
/// <summary> /// Gets if an <see cref="ISpatial"/> and another <see cref="ISpatial"/> occupy any common space. /// </summary> /// <param name="a">The first <see cref="ISpatial"/>.</param> /// <param name="b">The other <see cref="ISpatial"/>.</param> /// <returns>True if the two occupy any common space; otherwise false.</returns> public static bool Intersects(this ISpatial a, ISpatial b) { var bRect = b.ToRectangle(); bool ret; a.ToRectangle().Intersects(ref bRect, out ret); return(ret); }
/// <summary> /// Gets the grid segments that the <paramref name="spatial"/> occupies. /// </summary> /// <param name="spatial">The <see cref="ISpatial"/> to get the segments for.</param> /// <param name="position">The position to treat the <see cref="spatial"/> as being at.</param> /// <returns>The grid segments that the <paramref name="spatial"/> occupies.</returns> protected IEnumerable <IGridSpatialCollectionSegment> GetSegments(ISpatial spatial, Vector2 position) { var min = WorldPositionToGridSegment(position); var max = WorldPositionToGridSegment(position + spatial.Size); var length = new Point(max.X - min.X, max.Y - min.Y); return(GetSegments(min, length)); }
/// <summary> /// Gets a <see cref="Rectangle"/> that represents the area that represents where this <see cref="ISpatial"/> /// is standing. /// </summary> /// <param name="spatial">The <see cref="ISpatial"/>.</param> /// <returns>A <see cref="Rectangle"/> that represents the area that represents where this <see cref="ISpatial"/> /// is standing.</returns> public static Rectangle GetStandingAreaRect(this ISpatial spatial) { var min = spatial.Position; var size = spatial.Size; var r = new Rectangle((int)min.X + 1, (int)(min.Y + size.Y - 1), (int)size.X - 2, 2); return(r); }
public bool Intersects <T>(out ISpatial spatial) where T : ISpatial { Vector2 nullVector; spatial = Cast <T>((int)Position.X, (int)Position.Y, (int)Direction.X, (int)Direction.Y, out nullVector); return(spatial != null); }
/// <summary> /// Finds the Minimal Translational Distance between two <see cref="ISpatial"/>s. /// </summary> /// <param name="source">Source (dynamic) <see cref="ISpatial"/> that will be the one moving.</param> /// <param name="target">Target (static) <see cref="ISpatial"/> that will not move.</param> /// <returns>The MTD for the <paramref name="source"/> to no longer intersect the <paramref name="target"/>.</returns> public static Vector2 MTD(ISpatial source, ISpatial target) { Vector2 srcMin = source.Position; Vector2 srcMax = source.Max; Vector2 tarMin = target.Position; Vector2 tarMax = target.Max; return(MTD(srcMin, srcMax, tarMin, tarMax)); }
public MeshProjectionTarget(DMesh3 mesh, ISpatial spatial) { Mesh = mesh; Spatial = spatial; if (Spatial == null) { Spatial = new DMeshAABBTree3(mesh, true); } }
private void DoService(ref BehaviorTreeContext context) { ISpatial p = spatial.Get(context, this); if (p != null) { positionSetter.Set(context, this, p.Position); } }
/// <summary> /// Finds the Minimal Translational Distance between two <see cref="ISpatial"/>s. /// </summary> /// <param name="source">Source (dynamic) <see cref="ISpatial"/> that will be the one moving.</param> /// <param name="target">Target (static) <see cref="ISpatial"/> that will not move.</param> /// <returns>The MTD for the <paramref name="source"/> to no longer intersect the <paramref name="target"/>.</returns> public static Vector2 MTD(ISpatial source, ISpatial target) { Vector2 srcMin = source.Position; Vector2 srcMax = source.Max; Vector2 tarMin = target.Position; Vector2 tarMax = target.Max; return MTD(srcMin, srcMax, tarMin, tarMax); }
/// <summary> /// Aligns an <see cref="ISpatial"/>'s position to the grid. /// </summary> /// <param name="spatial">The <see cref="ISpatial"/>.</param> /// <param name="forceAlign">When true, aligning to the grid will be forced.</param> /// <returns>The position for the <paramref name="spatial"/>.</returns> /// <exception cref="ArgumentNullException"><paramref name="spatial"/> is null.</exception> public Vector2 Align(ISpatial spatial, bool forceAlign = false) { if (spatial == null) { throw new ArgumentNullException("spatial"); } return(Align(spatial.Position, forceAlign)); }
/// <summary> /// Initializes a new instance of the <see cref="TransBox"/> class. /// </summary> /// <param name="owner">The <see cref="TransBoxManager"/>.</param> /// <param name="type">The <see cref="TransBoxType"/>.</param> /// <param name="spatial">The <see cref="ISpatial"/>.</param> TransBox(TransBoxManager owner, TransBoxType type, ISpatial spatial) { _owner = owner; _type = type; _spatial = spatial; _size = GetTransBoxSize(type); _position = GetPosition(); }
/// <summary> /// Find distance from point to mesh /// Returns interpolated vertex-normal frame if available, otherwise tri-normal frame. /// </summary> public static double NearestPointDistance(DMesh3 mesh, ISpatial spatial, Vector3d queryPoint, double maxDist = double.MaxValue) { int tid = spatial.FindNearestTriangle(queryPoint, maxDist); if (tid == DMesh3.InvalidID) { return(double.MaxValue); } return(Math.Sqrt(TriangleDistance(mesh, tid, queryPoint).DistanceSquared)); }
private void AddEntityGrh(ISpatial entity, Grh grh) { // Find the scaling value so we can position the entities correctly var scaleX = GamePlayScreen.Map.Size.X / ScaledMapGrh.Size.X; var scaleY = GamePlayScreen.Map.Size.Y / ScaledMapGrh.Size.Y; var scaledPos = new Vector2((entity.Position.X / scaleX) - grh.Size.X / 2, (entity.Position.Y / scaleY) - grh.Size.Y / 2); // Add the grh as well as the position _grhEntities.Add(new Tuple <Grh, Vector2>(new Grh(grh.GrhData), scaledPos)); }
public static string Write(this SpatialFormatter<TextReader, TextWriter> formatter, ISpatial spatial) { Util.CheckArgumentNull(formatter, "formatter"); StringBuilder sb = new StringBuilder(); using (TextWriter writer = new StringWriter(sb, CultureInfo.InvariantCulture)) { formatter.Write(spatial, writer); } return sb.ToString(); }
/// <summary> /// Initializes a new instance of the <see cref="MapGrhEffectLoopOnce"/> class. /// </summary> /// <param name="grh">Grh to draw.</param> /// <param name="position">Position to draw on the map.</param> /// <param name="target">The <see cref="ISpatial"/> to seek out.</param> /// <param name="speed">How fast this object moves towards the target in pixels per second.</param> /// <exception cref="ArgumentNullException"><paramref name="target"/> is null.</exception> public MapGrhEffectSeekSpatial(Grh grh, Vector2 position, ISpatial target, float speed) : base(grh, position) { if (target == null) throw new ArgumentNullException("target"); _lastUpdate = TickCount.Now; _target = target; _speed = speed / 1000f; }
public static string Write(this SpatialFormatter<XmlReader, XmlWriter> formatter, ISpatial spatial) { Util.CheckArgumentNull(formatter, "formatter"); StringBuilder output = new StringBuilder(); XmlWriterSettings settings = new XmlWriterSettings { OmitXmlDeclaration = true }; using (XmlWriter writer = XmlWriter.Create(output, settings)) { formatter.Write(spatial, writer); } return output.ToString(); }
/// <summary> /// Finds the Minimal Translational Distance between two <see cref="ISpatial"/>s. /// </summary> /// <param name="source">Source (dynamic) <see cref="ISpatial"/> that will be the one moving.</param> /// <param name="target">Target (static) <see cref="ISpatial"/> that will not move.</param> /// <returns>The MTD for the <paramref name="source"/> to no longer intersect the <paramref name="target"/>.</returns> public static Vector2 MTD(ISpatial source, ISpatial target) { var srcMin = source.Position; var srcMax = source.Max; var tarMin = target.Position; var tarMax = target.Max; // Down var mtd = source.Max.Y - tarMin.Y; var side = BoxSide.Bottom; // Left var diff = srcMax.X - tarMin.X; if (diff < mtd) { mtd = diff; side = BoxSide.Left; } // Right diff = tarMax.X - srcMin.X; if (diff < mtd) { mtd = diff; side = BoxSide.Right; } // Up diff = tarMax.Y - srcMin.Y; if (diff < mtd) { mtd = diff; side = BoxSide.Top; } if (mtd < 0.0f) return Vector2.Zero; return CreateMTDVector(side, mtd + 1); }
/// <summary> /// Converts a spatial value into a string representation suitable for the specified format. If specified, injects a type name into the JSON format(s). /// </summary> /// <param name="format">The format to create the spatial value string representation for.</param> /// <param name="spatial">The spatial value.</param> /// <param name="typeName">The (optional) type name to inject into a JSON string representation.</param> /// <returns>The string representation of the spatial value in the specified format.</returns> /// <remarks>When using a type name with the JSON Light format, the resulting string representation will be invalid /// (since the odata.type annotation is not supported inside of spatial values); only used for error tests.</remarks> public static string GetSpatialStringValue(ODataFormat format, ISpatial spatial, string typeName = null) { if (format == ODataFormat.Atom) { return GmlFormatter.Create().Write(spatial); } IDictionary<string, object> dictionary = GeoJsonObjectFormatter.Create().Write(spatial); var converter = new DictionaryToJsonObjectConverter(); ExceptionUtilities.CheckAllRequiredDependencies(converter); var jsonObject = converter.Convert(dictionary); if (typeName != null) { // NOTE: using a type name with the JSON Light format will produce invalid payloads and is only used // for error tests. jsonObject.Insert(0, new JsonProperty(JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataTypeAnnotationName, new JsonPrimitiveValue(typeName))); } return jsonObject.ToText(format == ODataFormat.Json, indent:false); }
/// <summary> /// Handles when the <see cref="IRefractionEffect.PositionProvider"/> moves. /// </summary> /// <param name="sender">The sender.</param> /// <param name="e">The event args.</param> void PositionProvider_Moved(ISpatial sender, EventArgs<Vector2> e) { // Avoid needless calculations on finding the position when there are no listeners for Moved if (Moved != null) { // Moved has listener(s) var oldValue = Position; _position = sender.Position; Moved.Raise(this, EventArgsHelper.Create(oldValue)); } else { // No Moved listeners _position = sender.Position; } }
/// <summary> /// Send a packet to every user in the map within a reasonable range from the origin. Use this for packets /// that only affect those who are already in view from the origin such as brief visual effects. /// </summary> /// <param name="origin">The <see cref="ISpatial"/> that the event comes from.</param> /// <param name="data">BitStream containing the data to send.</param> /// <param name="messageType">The <see cref="ServerMessageType"/> to use for sending the <paramref name="data"/>.</param> public void SendToArea(ISpatial origin, BitStream data, ServerMessageType messageType) { SendToArea(origin.Position + (origin.Size / 2f), data, messageType); }
/// <summary> /// Initializes a new instance of the <see cref="WaterRefractionEffect"/> class. /// </summary> /// <param name="waveNoise">The sprite to use for the wave noise.</param> /// <param name="positionProvider">The <see cref="ISpatial"/> that will provide the positioning.</param> /// <param name="size">The size of the effect in pixels.</param> /// <param name="shader">The <see cref="Shader"/> to use to draw the water's refraction map. If null, the /// <see cref="WaterRefractionEffect.DefaultShader"/> will be used. If you provide your own shader, you must /// make sure that you either use the same effect parameters the default shader uses, or override this class /// so you can override the <see cref="WaterRefractionEffect.SetShaderParameters"/> method and set the parameters /// you require.</param> /// <exception cref="ArgumentNullException"><paramref name="waveNoise"/> is null.</exception> /// <exception cref="NullReferenceException"><paramref name="positionProvider"/> is null.</exception> public WaterRefractionEffect(Grh waveNoise, ISpatial positionProvider, Vector2 size, Shader shader = null) : this(waveNoise, positionProvider.Position, size, shader) { PositionProvider = positionProvider; }
/// <summary> /// Checks if a specified object is in view of the camera. /// </summary> /// <param name="spatial">The <see cref="ISpatial"/> to check if in view.</param> /// <returns> /// True if in the view area; otherwise false. /// </returns> public bool InView(ISpatial spatial) { if (spatial == null) { const string errmsg = "spatial is null."; Debug.Fail(errmsg); if (log.IsErrorEnabled) log.Error(errmsg); return false; } return InView(spatial.Position, spatial.Size); }
/// <summary> /// Finds the Users close enough to the <paramref name="toSynchronize"/> to synchronize their /// Position and Velocity to. /// </summary> /// <param name="toSynchronize">The <see cref="ISpatial"/> to synchronize.</param> /// <returns>An IEnumerable of Users close enough to the <paramref name="toSynchronize"/> that they /// need to have the <paramref name="toSynchronize"/>'s Position and Velocity synchronized.</returns> IEnumerable<User> GetUsersToSyncPandVTo(ISpatial toSynchronize) { int xPad = (int)(GameData.ScreenSize.X * 1.5); int yPad = (int)(GameData.ScreenSize.Y * 1.5); var syncRegion = toSynchronize.ToRectangle().Inflate(xPad, yPad); foreach (var user in Users) { Rectangle userRegion = user.ToRectangle(); if (syncRegion.Intersects(userRegion)) yield return user; } }
private void AddEntityGrh(ISpatial entity, Grh grh) { // Find the scaling value so we can position the entities correctly var scaleX = GamePlayScreen.Map.Size.X / ScaledMapGrh.Size.X; var scaleY = GamePlayScreen.Map.Size.Y / ScaledMapGrh.Size.Y; var scaledPos = new Vector2((entity.Position.X / scaleX) - grh.Size.X / 2, (entity.Position.Y / scaleY) - grh.Size.Y / 2); // Add the grh as well as the position _grhEntities.Add(new Tuple<Grh, Vector2>(new Grh(grh.GrhData), scaledPos)); }
/// <summary> /// Handles when an ItemEntity is resized. /// </summary> /// <param name="sender">The <see cref="ItemEntity"/> that was resized.</param> /// <param name="e">The <see cref="NetGore.EventArgs{Vector2}"/> instance containing the event data.</param> void ItemEntity_Resized(ISpatial sender, EventArgs<Vector2> e) { Debug.Assert(sender == this, "Why did we receive an ItemEntity_OnResize for another Entity?"); // Get the sizes as a byte var oldWidth = (byte)e.Item1.X; var oldHeight = (byte)e.Item1.Y; var width = (byte)sender.Size.X; var height = (byte)sender.Size.Y; // Update the changed sizes if (oldWidth != width) SynchronizeField("width", width); if (oldHeight != height) SynchronizeField("height", height); }
/// <summary> /// Gets if the <paramref name="shopper"/> is close enough to the <paramref name="shopOwner"/> to shop. /// </summary> /// <param name="shopper">The <see cref="Entity"/> doing the shopping.</param> /// <param name="shopOwner">The <see cref="Entity"/> that owns the shop.</param> /// <returns>True if the <paramref name="shopper"/> is close enough to the <paramref name="shopOwner"/> to /// shop; otherwise false.</returns> public static bool IsValidDistanceToShop(ISpatial shopper, ISpatial shopOwner) { var area = GetValidShopArea(shopper); return shopOwner.Intersects(area); }
/// <summary> /// Checks if an <see cref="ISpatial"/> is close enough to another <see cref="ISpatial"/> to pick it up. /// </summary> /// <param name="grabber">The <see cref="ISpatial"/> doing the picking up.</param> /// <param name="toGrab">The <see cref="ISpatial"/> being picked up.</param> /// <returns>True if the <paramref name="grabber"/> is close enough to the <paramref name="toGrab"/> /// to pick it up; otherwise false.</returns> public static bool IsValidPickupDistance(ISpatial grabber, ISpatial toGrab) { var region = GetPickupArea(grabber); return toGrab.Intersects(region); }
/// <summary> /// Gets a <see cref="Rectangle"/> that represents the valid area that items can be picked up at from /// the given <paramref name="spatial"/>. /// </summary> /// <param name="spatial">The <see cref="ISpatial"/> doing the picking-up.</param> /// <returns>A <see cref="Rectangle"/> that represents the area region that items can be picked up at from /// the given <paramref name="spatial"/>.</returns> public static Rectangle GetPickupArea(ISpatial spatial) { const int padding = 70; return spatial.ToRectangle().Inflate(padding); }
/// <summary> /// Gets a <see cref="Rectangle"/> containing the area that the <paramref name="shopper"/> may use to /// shop. Any <see cref="Entity"/> that owns a shop and intersects with this area is considered in a valid /// distance to shop with. /// </summary> /// <param name="shopper">The <see cref="Entity"/> doing the shopping.</param> /// <returns>A <see cref="Rectangle"/> containing the area that the <paramref name="shopper"/> may use to /// shop.</returns> public static Rectangle GetValidShopArea(ISpatial shopper) { return shopper.ToRectangle(); }
/// <summary> /// Gets the top-left corner to use for drawing for the given <paramref name="target"/>. /// </summary> /// <param name="target">The <see cref="ISpatial"/> to attach the bubble to.</param> /// <returns>The coordinate of the top-left corner of the <paramref name="target"/> to use for drawing.</returns> static Vector2 GetTopLeftCorner(ISpatial target) { return target.Position; }
/// <summary> /// Handles when the <see cref="ILight.PositionProvider"/> moves. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="EventArgs{Vector2}"/> instance containing the event data.</param> void PositionProvider_Moved(ISpatial sender, EventArgs<Vector2> e) { _position = sender.Position; }
/// <summary> /// Draws a <see cref="Rectangle"/>. /// </summary> /// <param name="sb"><see cref="ISpriteBatch"/> to draw to.</param> /// <param name="color">Color to draw the CollisionBox.</param> static void Draw(ISpriteBatch sb, ISpatial spatial, Color color, bool border = true) { Draw(sb, spatial.Position, spatial.Size, color, border); }
/// <summary> /// Gets the top-left corner to use for drawing for the given <paramref name="target"/>. /// </summary> /// <param name="target">The <see cref="ISpatial"/> to attach the bubble to.</param> /// <returns>The coordinate of the top-left corner of the <paramref name="target"/> to use for drawing.</returns> Vector2 GetTopLeftDrawCorner(ISpatial target) { Character asCharacter; // Make use of the Character's DrawPosition, otherwise it will look like the bubble is moving all over // the place since Characters like to interpolate all over the place if ((asCharacter = target as Character) != null) return asCharacter.LastScreenPosition; else return target.Position - World.Camera.Min; }
/// <summary> /// Finds the Users close enough to the <paramref name="toSynchronize"/> to synchronize their /// Position and Velocity to. /// </summary> /// <param name="toSynchronize">The <see cref="ISpatial"/> to synchronize.</param> /// <returns>An IEnumerable of Users close enough to the <paramref name="toSynchronize"/> that they /// need to have the <paramref name="toSynchronize"/>'s Position and Velocity synchronized.</returns> IEnumerable<User> GetUsersToSyncPandVTo(ISpatial toSynchronize) { var xPad = (int)(GameData.ScreenSize.X * 1.5); var yPad = (int)(GameData.ScreenSize.Y * 1.5); var r = toSynchronize.ToRectangle(); var syncRegion = new Rectangle(r.X - xPad, r.Y - yPad, r.Width + xPad * 2, r.Height + xPad * 2); foreach (var user in Users) { var userRegion = user.ToRectangle(); if (syncRegion.Intersects(userRegion)) yield return user; } }
/// <summary> /// Gets if an <see cref="ISpatial"/> and another <see cref="ISpatial"/> occupy any common space. /// </summary> /// <param name="a">The first <see cref="ISpatial"/>.</param> /// <param name="b">The other <see cref="ISpatial"/>.</param> /// <returns>True if the two occupy any common space; otherwise false.</returns> public static bool Intersects(this ISpatial a, ISpatial b) { var bRect = b.ToRectangle(); bool ret; a.ToRectangle().Intersects(ref bRect, out ret); return ret; }
/// <summary> /// Creates a <see cref="Rectangle"/> describing the area of a <see cref="ISpatial"/>. /// </summary> /// <param name="spatial">The <see cref="ISpatial"/> to get the <see cref="Rectangle"/> for.</param> /// <returns>A <see cref="Rectangle"/> describing the area of a <see cref="ISpatial"/>.</returns> public static Rectangle ToRectangle(ISpatial spatial) { return new Rectangle((int)spatial.Position.X, (int)spatial.Position.Y, (int)spatial.Size.X, (int)spatial.Size.Y); }
public static string GetUriLiteral(Type type, ISpatial spatial) { string typePrefix = typeof(Geometry).IsAssignableFrom(type) ? "geometry" : "geography"; return string.Format("{0}'{1}'", typePrefix, WellKnownTextSqlFormatter.Create().Write(spatial)); }
/// <summary> /// Handles when one of the bound walls have changed. /// </summary> /// <param name="sender">The sender.</param> /// <param name="e">The <see cref="NetGore.EventArgs{Vector2}"/> instance containing the event data.</param> void BoundWallChanged(ISpatial sender, EventArgs<Vector2> e) { var index = lstWalls.Items.IndexOf(sender); if (index < 0) return; lstWalls.RefreshItemAt(index); }
/// <summary> /// Gets if an <see cref="ISpatial"/> is fully contained inside of another <see cref="ISpatial"/>. That is, if /// the <see cref="contained"/> resides completely inside of the <see cref="container"/>. /// </summary> /// <param name="container">The <see cref="ISpatial"/> to check if it contains the <see cref="contained"/>.</param> /// <param name="contained">The <see cref="ISpatial"/> to check if is contained.</param> /// <returns>If the <paramref name="contained"/> is fully contained inside of the /// <paramref name="container"/>.</returns> public static bool Contains(this ISpatial container, ISpatial contained) { return container.ToRectangle().Contains(contained.ToRectangle()); }
/// <summary> /// Gets the distance between this <see cref="ISpatial"/> and another. /// </summary> /// <param name="spatial">The first <see cref="ISpatial"/>.</param> /// <param name="other">The other <see cref="ISpatial"/>.</param> /// <returns>The distance between this <see cref="ISpatial"/> and another <see cref="ISpatial"/> as an /// absolute value greater than or equal to zero. If this intersects <paramref name="other"/>, the /// value will be 0. Otherwise, the value will be the length of the shortest path between the two /// <see cref="ISpatial"/>s.</returns> public static int GetDistance(this ISpatial spatial, ISpatial other) { return spatial.ToRectangle().GetDistance(other.ToRectangle()); }