public frmAnimatedTileManager(Map map, Image tilesheet)
{
InitializeComponent();
this.Icon = Icon.FromHandle(Resources.imgFilm.GetHicon());
this.map = map;
this.tilesheet = tilesheet;
}
public frmProperty(Map map)
{
InitializeComponent();
this.Map = map;
this.LastMapSize = new MapPoint(map.MapSize.X, map.MapSize.Y);
this.IsNewMap = false;
this.LoadPropertes(this.IsNewMap);
}
public frmAnimatedTile(Map map, Image tilesheetimage, FrameAnimation animation)
{
InitializeComponent();
this.Icon = Icon.FromHandle(Resources.imgFilm.GetHicon());
this.Tile = animation;
this.map = map;
this.tilesheetimage = tilesheetimage;
this.DisplayTile();
}
public bool RemoveEvent(Map map, IMapEvent mapevent)
{
return this.RemoveEvent(map.Name, mapevent);
}
public void ReferenceSetOrAdd(Map map, IMapEvent mapevent)
{
this.ReferenceSetOrAdd(map.Name, mapevent);
}
public static void SetCurrentMap(Map map)
{
if (map == null)
throw new ArgumentNullException("map");
GameInstance.Engine.WorldManager.ClearWorlds();
MapEditorManager.CurrentMap = map;
MapHeader header = new MapHeader(map.Name, new MapPoint(0, 0), string.Empty);
header.Map = map;
World world = new World("Default");
world.AddMap(header);
GameInstance.Engine.WorldManager.AddWorld(world);
var camera = GameInstance.Engine.SceneProvider.Cameras.GetItems().FirstOrDefault().Value;
if (camera != null)
{
camera.CenterOriginOnPoint(0, 0);
camera.CurrentMap = header;
}
ActionManager.Reset();
}
public static void SaveMap(Map map, FileInfo location)
{
XmlDocument doc = new XmlDocument();
var mapElement = doc.CreateElement("Map");
var name = doc.CreateElement("Name");
name.InnerText = map.Name;
var tileset = doc.CreateElement("TileSet");
tileset.InnerText = map.TextureName;
var mapsize = doc.CreateElement("MapSize");
var mapsizex = doc.CreateElement("X");
mapsizex.InnerText = map.MapSize.X.ToString();
var mapsizey = doc.CreateElement("Y");
mapsizey.InnerText = map.MapSize.Y.ToString();
var tilepixelsize = doc.CreateElement("TilePixelSize");
tilepixelsize.InnerText = map.TileSize.ToString();
// Under Layer
var underlayer = doc.CreateElement("UnderLayer");
var underlayerbuilder = new StringBuilder();
for (int i = 0; i < map.UnderLayer.Length; i++)
{
underlayerbuilder.Append(map.UnderLayer[i]);
underlayerbuilder.Append(" ");
}
underlayer.InnerText = underlayerbuilder.ToString();
// Base Layer
var baselayer = doc.CreateElement("BaseLayer");
var baselayerbuilder = new StringBuilder();
for (int i = 0; i < map.BaseLayer.Length; i++)
{
baselayerbuilder.Append(map.BaseLayer[i]);
baselayerbuilder.Append(" ");
}
baselayer.InnerText = baselayerbuilder.ToString();
// Middle Layer
var middlelayer = doc.CreateElement("MiddleLayer");
var middlelayerbuilder = new StringBuilder();
for (int i = 0; i < map.MiddleLayer.Length; i++)
{
middlelayerbuilder.Append(map.MiddleLayer[i]);
middlelayerbuilder.Append(" ");
}
middlelayer.InnerText = middlelayerbuilder.ToString();
// Top Layer
var toplayer = doc.CreateElement("TopLayer");
var toplayerbuilder = new StringBuilder();
for (int i = 0; i < map.TopLayer.Length; i++)
{
toplayerbuilder.Append(map.TopLayer[i]);
toplayerbuilder.Append(" ");
}
toplayer.InnerText = toplayerbuilder.ToString();
// Collision Layer
var collisionLayer = doc.CreateElement("CollisionLayer");
var collisionlayerbuilder = new StringBuilder();
for (int i = 0; i < map.CollisionLayer.Length; i++)
{
collisionlayerbuilder.Append(map.CollisionLayer[i]);
collisionlayerbuilder.Append(" ");
}
collisionLayer.InnerText = collisionlayerbuilder.ToString();
// Opaque Layer
var opaqueLayer = doc.CreateElement("OpaqueLayer");
var opaquelayerbuilder = new StringBuilder();
for (int i = 0; i < map.OpaqueLayer.Length; i++)
{
opaquelayerbuilder.Append(map.OpaqueLayer[i]);
opaquelayerbuilder.Append(" ");
}
opaqueLayer.InnerText = opaquelayerbuilder.ToString();
// Events
var eventLayer = doc.CreateElement("Events");
foreach (IMapEvent mapevent in GameInstance.Engine.EventProvider.GetMapsEvents(map.Name))
{
eventLayer.AppendChild(EventToXmlNode(mapevent, doc));
}
// Animations
var animations = doc.CreateElement("AnimatedTiles");
foreach (var FrameAnimation in map.AnimatedTiles.Values)
{
var tileNode = doc.CreateElement("AnimatedTile");
var tileid = doc.CreateElement("TileID");
tileid.InnerText = ((FrameAnimation.InitialFrameRect.Y / CurrentMap.TileSize) * CurrentMap.TilesPerRow + FrameAnimation.InitialFrameRect.X).ToString();
var tilerect = doc.CreateElement("TileRect");
tilerect.InnerText = string.Format("{0} {1} {2} {3}", FrameAnimation.InitialFrameRect.X, FrameAnimation.InitialFrameRect.Y, FrameAnimation.InitialFrameRect.Width, FrameAnimation.InitialFrameRect.Height);
var framecount = doc.CreateElement("FrameCount");
framecount.InnerText = FrameAnimation.FrameCount.ToString();
tileNode.AppendChild(tileid);
tileNode.AppendChild(tilerect);
tileNode.AppendChild(framecount);
animations.AppendChild(tileNode);
}
// Append children and save
mapsize.AppendChild(mapsizex);
mapsize.AppendChild(mapsizey);
mapElement.AppendChild(name);
mapElement.AppendChild(tileset);
mapElement.AppendChild(mapsize);
mapElement.AppendChild(tilepixelsize);
mapElement.AppendChild(underlayer);
mapElement.AppendChild(baselayer);
mapElement.AppendChild(middlelayer);
mapElement.AppendChild(toplayer);
mapElement.AppendChild(collisionLayer);
mapElement.AppendChild(opaqueLayer);
mapElement.AppendChild(eventLayer);
mapElement.AppendChild(animations);
doc.AppendChild(mapElement);
doc.Save(location.FullName);
}
/// <summary>
/// Performs a flood fill beginning on the target square
/// </summary>
/// <param name="map">The map to perform the operation on</param>
/// <param name="layer">The layer to perform on</param>
/// <param name="x">The x location to begin filling</param>
/// <param name="y">The y location to begin filling</param>
/// <param name="oldtileid">The ID of the tile to begin replacing.</param>
/// <param name="newtileid">The ID of the replacement tile.</param>
private void FloodFill(Map map, MapLayers layer, int x, int y, int oldtileid, int newtileid)
{
int value = map.GetLayerValue(new MapPoint(x, y), layer);
if (value != oldtileid || value == newtileid)
return;
var action = new PlaceTileAction(x, y, layer, newtileid);
action.Do(context);
tmpactions.Add(action);
if (x + 1 < MapEditorManager.CurrentMap.MapSize.X)
this.FloodFill(map, layer, x + 1, y, oldtileid, newtileid);
if (x - 1 >= 0)
this.FloodFill(map, layer, x - 1, y, oldtileid, newtileid);
if (y + 1 < MapEditorManager.CurrentMap.MapSize.Y)
this.FloodFill(map, layer, x, y + 1, oldtileid, newtileid);
if (y - 1 >= 0)
this.FloodFill(map, layer, x, y - 1, oldtileid, newtileid);
}
private void PlotLayerTile(SpriteBatch spritebatch, Map map, Rectangle destrect, int tilevalue)
{
Check.NullArgument<SpriteBatch>(spritebatch, "spritebatch");
Check.NullArgument<Map>(map, "map");
Rectangle sourcerect = this.GetSourceRect(map, tilevalue);
spritebatch.Draw (map.Texture, destrect, sourcerect, Color.White);
}
public IEnumerable<IMapEvent> GetMapsEvents(Map map)
{
return this.GetMapsEvents(map.Name);
}
private Rectangle GetSourceRect(Map map, int value)
{
Check.NullArgument<Map>(map, "map");
return new Rectangle(
(value % map.TilesPerRow) * map.TileSize,
(value / map.TilesPerRow) * map.TileSize,
map.TileSize - 1, map.TileSize - 1);
}
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;
}
}
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();
}
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 AddEvent(Map map, IMapEvent mapevent)
{
this.AddEvent (map.Name, mapevent);
}
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 int GetMapsEventCount(Map map)
{
return this.GetMapsEventCount(map.Name);
}
private void DisplayMapProperties(Map map)
{
this.lstSettings.Items.Clear();
this.lstSettings.Items.Add(new ListViewItem(new string[] { "Name", map.Name }));
this.lstSettings.Items.Add(new ListViewItem(new string[] { "Tile Size", map.TileSize.ToString() }));
this.lstSettings.Items.Add(new ListViewItem(new string[] { "Tile Set", map.TextureName }));
this.lstSettings.Items.Add(new ListViewItem(new string[] { "Tiles Per Row", map.TilesPerRow.ToString() }));
this.lstSettings.Items.Add(new ListViewItem(new string[] { "Map Size", map.MapSize.ToString() }));
this.UpdateScrollBars(true);
this.EnableToolButtons(true);
}
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);
}
public frmAnimatedTile(Map map, Image tilesheet)
: this(map, tilesheet, new FrameAnimation(0, 0, 0, 0, 0))
{
}
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 static Map ApplyMapProperties(Map oldMap)
{
return MapEditorManager.ResizeMap(oldMap, oldMap.MapSize);
}
private void DisplayTileSheet(Map map)
{
this.pctTileSurface.Image = Image.FromFile(
Path.Combine(MapEditorManager.GameInstance.Engine.Configuration[EngineConfigurationName.GraphicsRoot], map.TextureName));
this.pctTileSurface.Size = this.pctTileSurface.Image.Size;
this.pctTileSurface.TileSize = new Point(map.TileSize, map.TileSize);
this.pctTileSurface.Invalidate();
}
public static Map ResizeMap(Map map, MapPoint newsize)
{
Map newMap = new Map();
newMap.Name = map.Name;
newMap.TextureName = map.TextureName;
newMap.Texture = map.Texture;
newMap.TileSize = map.TileSize;
foreach (var animation in map.AnimatedTiles)
newMap.AnimatedTiles.Add(animation.Key, animation.Value);
newMap.MapSize = newsize;
newMap.UnderLayer = new int[newsize.IntX * newsize.IntY];
newMap.BaseLayer = new int[newsize.IntX * newsize.IntY];
newMap.MiddleLayer = new int[newsize.IntX * newsize.IntY];
newMap.TopLayer = new int[newsize.IntX * newsize.IntY];
newMap.CollisionLayer = new int[newsize.IntX * newsize.IntY];
newMap.OpaqueLayer = new int[newsize.IntX * newsize.IntY];
for (int i = 0; i < (newMap.MapSize.X * newMap.MapSize.Y); i++)
{
newMap.UnderLayer[i] = -1;
newMap.BaseLayer[i] = -1;
newMap.MiddleLayer[i] = -1;
newMap.TopLayer[i] = -1;
newMap.CollisionLayer[i] = -1;
newMap.OpaqueLayer[i] = -1;
}
for (int y = 0; y < newsize.Y; y++)
{
for (int x = 0; x < newsize.X; x++)
{
// If it's outside the Y range always fill with -1
if (y >= map.MapSize.Y)
{
newMap.SetLayerValue(new MapPoint(x, y), MapLayers.UnderLayer, -1);
continue;
}
// If it's outside the X range but not the Y range, fill with 0
if (x >= map.MapSize.X)
{
newMap.SetLayerValue(new MapPoint(x, y), MapLayers.UnderLayer, -1);
continue;
}
//Fill the new location with the value of the old location
newMap.SetLayerValue(new MapPoint(x, y), MapLayers.UnderLayer, map.GetLayerValue(new MapPoint(x, y), MapLayers.UnderLayer));
newMap.SetLayerValue(new MapPoint(x, y), MapLayers.BaseLayer, map.GetLayerValue(new MapPoint(x, y), MapLayers.BaseLayer));
newMap.SetLayerValue(new MapPoint(x, y), MapLayers.MiddleLayer, map.GetLayerValue(new MapPoint(x, y), MapLayers.MiddleLayer));
newMap.SetLayerValue(new MapPoint(x, y), MapLayers.TopLayer, map.GetLayerValue(new MapPoint(x, y), MapLayers.TopLayer));
newMap.SetLayerValue(new MapPoint(x, y), MapLayers.CollisionLayer, map.GetLayerValue(new MapPoint(x, y), MapLayers.CollisionLayer));
newMap.SetLayerValue(new MapPoint(x, y), MapLayers.OpaqueLayer, map.GetLayerValue(new MapPoint(x, y), MapLayers.OpaqueLayer));
}
}
return newMap;
}
