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);
}
