public void LoadContent(GraphicsDevice graphicsDevice, IEngineContext context) { this.context = context; this.startpoint = GetNegativeOne(); this.endpoint = GetNegativeOne(); }
public MapHeader GetLocalMapFromPoint(MapPoint globalpoint) { foreach(MapHeader header in this.Maps.Values) { Rectangle rect = (header.MapLocation).ToRect(header.Map.MapSize.ToPoint()); if(rect.Contains(globalpoint.ToPoint())) { return header; } } return null; }
public void CreateOrEditEvent(Rectangle selectedRect) { MapEditorManager.IgnoreInput = true; var camera = this.context.SceneProvider.Cameras["camera1"]; int xOffset = (int)camera.Location.X / 32; int yOffset = (int)camera.Location.Y / 32; IMapEvent mapevent = this.context.EventProvider.GetMapsEvents(MapEditorManager.CurrentMap.Name).Where(e => e.Rectangle.Intersects(selectedRect)).FirstOrDefault(); bool newEvent = false; if (mapevent != null) { SelectedPoint = new Point(mapevent.Rectangle.X * 32, mapevent.Rectangle.Y * 32); EndSelectedPoint = new Point((mapevent.Rectangle.X * 32) + ((mapevent.Rectangle.Width - 1) * 32), (mapevent.Rectangle.Y * 32) + ((mapevent.Rectangle.Height - 1) * 32)); } else { newEvent = true; } MapPoint size = new MapPoint(((this.EndSelectedPoint.X - this.SelectedPoint.X) / 32) + 1, ((this.EndSelectedPoint.Y - this.SelectedPoint.Y) / 32) + 1); frmMapEvent dialog = new frmMapEvent(mapevent); DialogResult result = dialog.ShowDialog(); mapevent = dialog.Event; if (mapevent != null) { if (!newEvent) mapevent.Rectangle = new Rectangle(mapevent.Rectangle.X, mapevent.Rectangle.Y, size.IntX, size.IntY); else mapevent.Rectangle = new Rectangle(selectedRect.X, selectedRect.Y, size.IntX, size.IntY); } if (result == DialogResult.OK) { this.context.EventProvider.ReferenceSetOrAdd(MapEditorManager.CurrentMap.Name, mapevent); MapEditorManager.OnMapChanged(); } else if (result == DialogResult.Abort) { this.context.EventProvider.RemoveEvent(MapEditorManager.CurrentMap.Name, mapevent); MapEditorManager.OnMapChanged(); } MapEditorManager.IgnoreInput = false; }
public bool CheckCollision(IMovable source, MapPoint Destination) { if(source.Density < 1) return true; World currentworld = this.context.WorldManager.GetWorld(source.WorldName); foreach(MapHeader header in currentworld.Maps.Values) { Rectangle rect = (header.MapLocation).ToRect(header.Map.MapSize.ToPoint()); if(rect.Contains(Destination.ToPoint())) { return (header.Map.GetLayerValue(Destination - header.MapLocation, MapLayers.CollisionLayer) == -1); } } return true; }
private Grabbable GetGrabbableAtPoint(MapPoint mpoint) { Check.NullArgument<MapPoint>(mpoint, "mpoint"); return this.grabbables.Where(g => g.ContainsPoint(mpoint)).FirstOrDefault(); }
private void DrawLayerMap(SpriteBatch spriteBatch, BaseCamera camera, MapLayers layer, MapHeader header, Color tint) { Check.NullArgument(spriteBatch, "spriteBatch"); Check.NullArgument(header, "header"); Map currentMap = header.Map; ScreenPoint camOffset = ScreenPoint.Zero;// camera.Offset; int tileSize = currentMap.TileSize; for (int y = 0; y < currentMap.MapSize.Y; y++) { for (int x = 0; x < currentMap.MapSize.X; x++) { ScreenPoint pos = new MapPoint(x, y).ToScreenPoint() + camOffset + header.MapLocation.ToScreenPoint(); Rectangle des = new Rectangle(pos.IntX, pos.IntY, tileSize, tileSize); MapPoint point = new MapPoint(x, y); if (!camera.CheckIsVisible(des)) continue; // Opaque only and not opaque var opacity = currentMap.GetLayerValue(point, MapLayers.OpaqueLayer); if (opacity >= 1) { var info = new Rectangle() { X = pos.IntX, Y = pos.IntY, Width = tileSize, Height = tileSize }; if(!this.lastfoginfos.Contains(info)) this.lastfoginfos.Add(info); } Rectangle sourceRectangle = currentMap.GetLayerSourceRect(point, layer); if (sourceRectangle.IsEmpty) continue; spriteBatch.Draw(currentMap.Texture, des, sourceRectangle, tint); } } }
public ScreenPoint(MapPoint mapPoint) : base((mapPoint * 32).ToPoint()) { }
public void RenderFog(SpriteBatch batch, BaseCamera camera, List<Rectangle> infos, MapPoint rayorigin) { }
public GrabbedTile(MapPoint offset) { this.Offset = offset; }
private MapPoint ConstrainPoint(Map map, MapPoint mpoint) { mpoint.IntX = mpoint.IntX.Clamp(0, map.MapSize.IntX - 1); mpoint.IntY = mpoint.IntY.Clamp(0, map.MapSize.IntY - 1); return mpoint; }
public GrabbedTile(MapPoint offset, int layer1, int layer2, int layer3, int layer4) { Offset = offset; Layer1 = layer1; Layer2 = layer2; Layer3 = layer3; Layer4 = layer3; }
public Map GetMap(string filepath, IEventProvider eventprovider) { Uri location = new Uri(filepath); FileInfo MapPath = new FileInfo(location.LocalPath); if (!MapPath.Exists) throw new ArgumentException("Invalid file path. Map does not exist.", "location"); Map Map = new Map(); XmlDocument doc = new XmlDocument(); doc.Load(MapPath.FullName); XmlNodeList nodes = doc.GetElementsByTagName("Map"); XmlNodeList innerNodes = nodes[0].ChildNodes; for (int i = 0; i < innerNodes.Count; i++) { if (innerNodes[i].Name == "Name") Map.Name = innerNodes[i].InnerText; else if (innerNodes[i].Name == "TileSet") Map.TextureName = innerNodes[i].InnerText; else if (innerNodes[i].Name == "MapSize") { int x = 0, y = 0; foreach (XmlNode node in innerNodes[i].ChildNodes) { if (node.Name == "X") x = Convert.ToInt32(node.InnerText); else if (node.Name == "Y") y = Convert.ToInt32(node.InnerText); } Map.MapSize = new MapPoint(x, y); } else if (innerNodes[i].Name == "TilePixelSize") { Map.TileSize = Convert.ToInt32(innerNodes[i].InnerText); } else if (innerNodes[i].Name == "UnderLayer") { string[] baseText = innerNodes[i].InnerText.Replace("\r\n", string.Empty).Replace(" ", string.Empty).Trim().Split(' '); Map.UnderLayer = Array.ConvertAll<string, int>(baseText, new Converter<string, int>(this.ConvertStringToInt)); } else if (innerNodes[i].Name == "BaseLayer") { string[] baseText = innerNodes[i].InnerText.Replace("\r\n", string.Empty).Replace(" ", string.Empty).Trim().Split(' '); Map.BaseLayer = Array.ConvertAll<string, int>(baseText, new Converter<string, int>(this.ConvertStringToInt)); } else if (innerNodes[i].Name == "MiddleLayer") { string[] baseText = innerNodes[i].InnerText.Replace("\r\n", string.Empty).Replace(" ", string.Empty).Trim().Split(' '); Map.MiddleLayer = Array.ConvertAll<string, int>(baseText, new Converter<string, int>(this.ConvertStringToInt)); } else if (innerNodes[i].Name == "TopLayer") { string[] baseText = innerNodes[i].InnerText.Replace("\r\n", string.Empty).Replace(" ", string.Empty).Trim().Split(' '); Map.TopLayer = Array.ConvertAll<string, int>(baseText, new Converter<string, int>(this.ConvertStringToInt)); } else if (innerNodes[i].Name == "CollisionLayer") { string[] baseText = innerNodes[i].InnerText.Replace("\r\n", string.Empty).Replace(" ", string.Empty).Trim().Split(' '); Map.CollisionLayer = Array.ConvertAll<string, int>(baseText, new Converter<string, int>(this.ConvertStringToInt)); } else if (innerNodes[i].Name == "OpaqueLayer") { string[] baseText = innerNodes[i].InnerText.Replace("\r\n", string.Empty).Replace(" ", string.Empty).Trim().Split(' '); Map.OpaqueLayer = Array.ConvertAll<string, int>(baseText, new Converter<string, int>(this.ConvertStringToInt)); } else if (innerNodes[i].Name == "AnimatedTiles") { XmlNodeList tiles = innerNodes[i].ChildNodes; foreach (XmlNode node in tiles) { int tileID = 0; int frameCount = 0; Rectangle tileRect = Rectangle.Empty; foreach (XmlNode subnode in node.ChildNodes) { if (subnode.Name == "TileID") tileID = Convert.ToInt32(subnode.InnerText); else if (subnode.Name == "FrameCount") frameCount = Convert.ToInt32(subnode.InnerText); else if (subnode.Name == "TileRect") { var data = Array.ConvertAll<string, int>(subnode.InnerText.Split(' '), new Converter<string, int>(this.ConvertStringToInt)); tileRect = new Rectangle(data[0], data[1], data[2], data[3]); } } Map.AnimatedTiles.Add(tileID, new FrameAnimation(tileRect, frameCount)); } } else if (innerNodes[i].Name == "Events") { var root = innerNodes[i]; XmlNodeList events = root.ChildNodes; foreach (XmlNode node in events) { #region Event Loading string type = string.Empty; Directions dir = Directions.Any; Dictionary<String, String> parameters = new Dictionary<string, string>(); MapPoint eventlocation = MapPoint.Zero; MapPoint size = MapPoint.Zero; ActivationTypes activation = ActivationTypes.Static; foreach (XmlNode cnode in node.ChildNodes) { switch (cnode.Name) { case "Type": type = cnode.InnerText; break; case "Dir": dir = (Directions)Enum.Parse(typeof(Directions), cnode.InnerText); break; case "Parameters": parameters = this.LoadParametersFromXml(cnode); break; case "Location": eventlocation = new MapPoint(cnode); break; case "Size": size = new MapPoint(cnode); break; case "Activation": activation = (ActivationTypes)Enum.Parse(typeof(ActivationTypes), cnode.InnerText); break; } } IMapEvent newEvent = this.CreateEventFromString(type); if (newEvent == null) { MapEditorManager.NoEvents = true; break; } newEvent.Direction = dir; newEvent.Parameters = parameters; newEvent.Rectangle = new Rectangle(eventlocation.IntX, eventlocation.IntY, size.IntX, size.IntY); newEvent.Activation = activation; eventprovider.AddEvent(Map, newEvent); #endregion } } } return Map; }
public void OnMouseUp(object sender, MouseEventArgs ev) { var rect = ComponentHelpers.GetSelectionRectangleTiles (this.startpoint.ToPoint(), this.endpoint.ToPoint()); this.PlotRectangleChunk(rect); this.startpoint = this.GetNegativeOne(); this.endpoint = this.GetNegativeOne(); this.isselecting = false; this.startedinwindow = false; }
private void DrawGrabbable(SpriteBatch spritebatch, BaseCamera camera, Map map, Grabbable grabbable) { Check.NullArgument<SpriteBatch>(spritebatch, "spritebatch"); Check.NullArgument<BaseCamera>(camera, "camera"); Check.NullArgument<Map>(map, "map"); Check.NullArgument<Grabbable>(grabbable, "grabbable"); var startpoint = grabbable.GetStartPoint(); spritebatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.LinearWrap, DepthStencilState.Default, RasterizerState.CullCounterClockwise, null, camera.TransformMatrix); foreach (var tile in grabbable.Tiles) { Rectangle destrect = new Rectangle((startpoint.IntX + tile.Offset.IntX ) * map.TileSize, (startpoint.IntY + tile.Offset.IntY) * map.TileSize, map.TileSize, map.TileSize); MapPoint mappoint = new MapPoint(startpoint.IntX + tile.Offset.IntX, startpoint.IntY + tile.Offset.IntY); if (!ComponentHelpers.PointInMap(map, mappoint)) continue; PlotLayerTile(spritebatch, map, destrect, tile.Layer1); PlotLayerTile(spritebatch, map, destrect, tile.Layer2); PlotLayerTile(spritebatch, map, destrect, tile.Layer3); PlotLayerTile(spritebatch, map, destrect, tile.Layer4); } spritebatch.End(); }
public bool HandleEvent(BaseCharacter player, ActivationTypes activation) { MapPoint pos = player.GlobalTileLocation; IEnumerable<IMapEvent> events = null; bool handledevents = false; if(player.CurrentMap == null) player.CurrentMap = this.context.SceneProvider.GetPositionableLocalMap (player); if(activation == ActivationTypes.OnMapEnter) { events = this.GetMapsEvents(player.CurrentMap.Map).Where (e => e.Activation == ActivationTypes.OnMapEnter); } else if(activation == ActivationTypes.Activate || activation == ActivationTypes.Collision) { MapPoint newpt = player.GetLookValue(); pos = new MapPoint(pos.X + newpt.X, pos.Y + newpt.Y); events = this.GetMapsEvents (player.WorldName, player.CurrentMap, pos); } else if(activation == ActivationTypes.Movement) { events = this.GetMapsEvents (player.WorldName, player.CurrentMap, pos); } // If we didn't find any events, return. if(events == null) return false; foreach(IMapEvent mapevent in events) { if(mapevent.Activation == ActivationTypes.Static) continue; if(mapevent.Direction == Directions.Any || mapevent.Direction == player.Direction && mapevent.Activation == activation) { mapevent.Trigger(player, this.context); handledevents = true; } } return handledevents; }
private Grabbable CreateGrabbable(Rectangle maprect, Map map, bool clearout) { Check.NullArgument<Map>(map, "map"); Grabbable grab = new Grabbable(maprect, true); int width = maprect.Width + 1; int height = maprect.Height + 1; ActionBatchAction<PlaceTileAction> batchaction = new ActionBatchAction<PlaceTileAction>(); for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { var mappoint = new MapPoint(x + maprect.X, y + maprect.Y); if (!ComponentHelpers.PointInMap(map, mappoint)) continue; GrabbedTile tile = new GrabbedTile(new MapPoint(x, y)) { Layer1 = map.GetLayerValue(mappoint, MapLayers.UnderLayer), Layer2 = map.GetLayerValue(mappoint, MapLayers.BaseLayer), Layer3 = map.GetLayerValue(mappoint, MapLayers.MiddleLayer), Layer4 = map.GetLayerValue(mappoint, MapLayers.TopLayer) }; grab.Tiles.Add(tile); } } return grab; }
private MapPoint ConstrainPoint(Map map, MapPoint mpoint) { Check.NullArgument<Map>(map, "map"); Check.NullArgument<MapPoint>(mpoint, "mpoint"); mpoint.IntX = mpoint.IntX.Clamp(0, map.MapSize.IntX - 1); mpoint.IntY = mpoint.IntY.Clamp(0, map.MapSize.IntY - 1); return mpoint; }
public void Update(GameTime gameTime) { if(!MapEditorManager.IsMapLoaded || MapEditorManager.IgnoreInput) return; var mouse = Mouse.GetState(); var camera = MapEditorManager.GameInstance.Engine.SceneProvider.Cameras["camera1"]; var map = MapEditorManager.CurrentMap; if (camera == null) return; if (isselecting) { this.endpoint = camera.ScreenSpaceToWorldSpace(new ScreenPoint(mouse.X, mouse.Y)).ToMapPoint(); this.endpoint = this.ConstrainPoint(map, this.endpoint); } }
public void OnMouseDown(object sender, MouseEventArgs ev) { if (!MapEditorManager.IsMapLoaded || MapEditorManager.IgnoreInput || ev.Button != MouseButtons.Left) return; var camera = MapEditorManager.GameInstance.Engine.SceneProvider.Cameras["camera1"]; var map = MapEditorManager.CurrentMap; if (!ComponentHelpers.PointInBounds(camera, ev.X, ev.Y) || camera == null) return; var grabpointmap = camera.ScreenSpaceToWorldSpace (new ScreenPoint(ev.X, ev.Y)).ToMapPoint(); bool ingrabbed = this.IsGrabbableAtPoint(grabpointmap); // We are grabbing and we clicked somewhere out of the grab region if (currentgrabed != null && !ingrabbed) { this.PutDownGrabbable(currentgrabed, map); this.grabbables.Clear(); this.currentgrabed = null; this.isgrabbing = false; } // We aren't grabbing and we grab a grabbable region else if (!this.isgrabbing && ingrabbed) { this.currentgrabed = this.GetGrabbableAtPoint(grabpointmap); var mappoint = camera.ScreenSpaceToWorldSpace(new ScreenPoint(ev.X, ev.Y)).ToMapPoint(); this.graboffset = mappoint - new MapPoint(this.currentgrabed.GetStartPoint()); this.isgrabbing = true; } // We aren't grabbing and we don't click in any grabbable regions if(!this.isgrabbing && !ingrabbed) { if(currentgrabed != null) this.PutDownGrabbable(currentgrabed, map); this.grabbables.Clear(); this.currentgrabed = null; this.isgrabbing = false; // Start selecting this.startpoint = camera.ScreenSpaceToWorldSpace(new ScreenPoint(ev.X, ev.Y)).ToMapPoint(); this.startpoint = this.ConstrainPoint(map, this.startpoint); this.endpoint = new MapPoint(startpoint.X, startpoint.Y); this.isselecting = true; } }
public void LoadContent(GraphicsDevice graphicsDevice, IEngineContext context) { this.device = graphicsDevice; this.context = context; startpoint = GetNegativeOne(); endpoint = GetNegativeOne(); graboffset = GetNegativeOne(); }
public IEnumerable<IMapEvent> GetMapsEvents(string worldname, MapHeader mapheader, MapPoint globalposition) { MapPoint pos = globalposition - mapheader.MapLocation; // If the globalposition is not located in the mapheader if(pos.X < 0 || pos.Y < 0 || pos.X > mapheader.Map.MapSize.X || pos.Y > mapheader.Map.MapSize.Y) { // Find globally MapHeader header = this.context.WorldManager.GetWorld (worldname).GetLocalMapFromPoint (globalposition); MapPoint localpos = globalposition - header.MapLocation; // Ensure no crash if(!this.events.ContainsKey (header.MapName)) this.events.Add (header.MapName, new List<IMapEvent> ()); return this.events[header.MapName].Where (m => m.Rectangle.Contains ((localpos).ToPoint ())); } else { if(!this.events.ContainsKey (mapheader.MapName)) return new List<IMapEvent> (); // Ensure no crash if(!this.events.ContainsKey (mapheader.MapName)) this.events.Add (mapheader.MapName, new List<IMapEvent> ()); return this.events[mapheader.MapName].Where (m => m.Rectangle.Contains ((pos).ToPoint ())); } }
private void GrabbableMoveClearAction(Grabbable g, MapPoint point, Map map) { // We moved, we haven't cleared, and we should clear tiles under our starting point if (point != g.CreatePoint && g.ClearOnMove && !g.Cleared) { ActionBatchAction<PlaceTileAction> batchaction = new ActionBatchAction<PlaceTileAction>(); foreach (var tile in g.Tiles) { var original = new MapPoint(g.CreatePoint.X + tile.Offset.X, g.CreatePoint.Y + tile.Offset.Y); batchaction.Add(new PlaceTileAction(original.IntX, original.IntY, MapLayers.UnderLayer, -1)); batchaction.Add(new PlaceTileAction(original.IntX, original.IntY, MapLayers.BaseLayer, -1)); batchaction.Add(new PlaceTileAction(original.IntX, original.IntY, MapLayers.MiddleLayer, -1)); batchaction.Add(new PlaceTileAction(original.IntX, original.IntY, MapLayers.TopLayer, -1)); } batchaction.Do(context); g.MoveClearActions = batchaction; g.Cleared = true; } }
public void EndMoveLocation(Character movable, MapPoint destination, string animationname) { //lock(this.movablecache) //{ // if(!this.movablecache.ContainsKey (movable)) // return; // this.movablecache[movable].Enqueue (new MovementItem (destination.ToScreenPoint (), MovementType.Destination, Directions.Any, animationname)); //} }
private bool IsGrabbableAtPoint(MapPoint mpoint) { return (this.GetGrabbableAtPoint(mpoint) != default(Grabbable)); }
public void Update(GameTime gameTime) { if (!MapEditorManager.IsMapLoaded || MapEditorManager.IgnoreInput || !startedinwindow) return; var mouse = Mouse.GetState(); var camera = MapEditorManager.GameInstance.Engine.SceneProvider.Cameras["camera1"]; var map = MapEditorManager.CurrentMap; if (camera == null || map == null) return; if (isselecting && mouse.LeftButton == Microsoft.Xna.Framework.Input.ButtonState.Pressed) { this.endpoint = camera.ScreenSpaceToWorldSpace(new ScreenPoint(mouse.X, mouse.Y)).ToMapPoint(); this.endpoint = this.ConstrainPoint(map, this.endpoint); } }
private void PutDownGrabbable(Grabbable grabbable, Map map) { Check.NullArgument<Grabbable>(grabbable, "grabbable"); Check.NullArgument<Map>(map, "map"); var startpoint = grabbable.GetStartPoint(); ActionBatchAction<PlaceTileAction> batchaction = new ActionBatchAction<PlaceTileAction>(); foreach (var tile in grabbable.Tiles) { var mappoint = new MapPoint(startpoint.X + tile.Offset.X, startpoint.Y + tile.Offset.Y); if (!ComponentHelpers.PointInMap(map, mappoint)) continue; batchaction.Add(new PlaceTileAction(mappoint.IntX, mappoint.IntY, MapLayers.UnderLayer, tile.Layer1)); batchaction.Add(new PlaceTileAction(mappoint.IntX, mappoint.IntY, MapLayers.BaseLayer, tile.Layer2)); batchaction.Add(new PlaceTileAction(mappoint.IntX, mappoint.IntY, MapLayers.MiddleLayer, tile.Layer3)); batchaction.Add(new PlaceTileAction(mappoint.IntX, mappoint.IntY, MapLayers.TopLayer, tile.Layer4)); } if (grabbable.CreatePoint != grabbable.GetStartPoint()) { MapEditorManager.ActionManager.PerformAction(batchaction); batchaction.AddRange(grabbable.MoveClearActions.Actions); } else batchaction.Do(context); }
/// <summary> /// Plots a chunk of tiles within a specified rectangle /// </summary> /// <param name="rect">The MapPoint based selection rectangle</param> private void PlotRectangleChunk(Rectangle rect) { var camera = this.context.SceneProvider.Cameras["camera1"]; var map = MapEditorManager.CurrentMap; var tilerect = MapEditorManager.SelectedTilesRectangle; var plotstart = new MapPoint(rect.X, rect.Y); ActionBatchAction<PlaceTileAction> batchactions = new ActionBatchAction<PlaceTileAction>(); // Keep track of where in the tile sheet we are int tilex = 0; int totalx = 0; int tiley = 0; for (int i = 0; i < rect.Width * rect.Height; i++) { int y = (i / rect.Width); int x = (i - (y * rect.Width)); MapPoint tilepoint = new MapPoint(plotstart.X + x, plotstart.Y + y); MapPoint sheetpoint = new MapPoint(tilerect.X + tilex, tilerect.Y + tiley); if (ComponentHelpers.PointInMap(map, tilepoint)) { batchactions.Add(new PlaceTileAction(tilepoint.IntX, tilepoint.IntY,MapEditorManager.CurrentLayer,map.GetTileSetValue(sheetpoint))); } tilex++; totalx++; if (tilex >= tilerect.Width || totalx >= rect.Width) { if (totalx >= rect.Width) { tiley++; totalx = 0; tilex = 0; } tilex = 0; } if (tiley >= tilerect.Height) tiley = 0; } MapEditorManager.ActionManager.PerformAction(batchactions); MapEditorManager.OnMapChanged(); }
public bool ContainsPoint(MapPoint point) { return new Rectangle(rect.X, rect.Y, rect.Width + 1, rect.Height + 1) .Contains(point.ToPoint()); }
public void OnMouseDown(object sender, MouseEventArgs ev) { if (!MapEditorManager.IsMapLoaded || MapEditorManager.IgnoreInput || ev.Button != MouseButtons.Left) return; var camera = MapEditorManager.GameInstance.Engine.SceneProvider.Cameras["camera1"]; var map = MapEditorManager.CurrentMap; if (!ComponentHelpers.PointInBounds(camera, ev.X, ev.Y) || camera == null) return; // Start selecting this.startpoint = camera.ScreenSpaceToWorldSpace(new ScreenPoint(ev.X, ev.Y)).ToMapPoint(); this.startpoint = this.ConstrainPoint(map, this.startpoint); this.endpoint = new MapPoint(startpoint.X, startpoint.Y); this.isselecting = true; this.startedinwindow = true; }
public void Move(MapPoint point) { this.Move(point.IntX, point.IntY); }