private void WriteTileLayerBlock(ContentWriter output, MultiTileGridLayer layer)
{
output.Write((short)layer.TileWidth);
output.Write((short)layer.TileHeight);
output.Write((short)layer.TilesWide);
output.Write((short)layer.TilesHigh);
int tscount = 0;
foreach (LocatedTileStack stack in layer.TileStacks)
{
tscount++;
}
output.Write(tscount);
foreach (LocatedTileStack stack in layer.TileStacks)
{
output.Write((short)stack.X);
output.Write((short)stack.Y);
output.Write((short)stack.Stack.Count);
foreach (Tile tile in stack.Stack)
{
output.Write((short)tile.Uid);
}
}
}
private void InitializeBrush(DynamicTileBrush brush)
{
_layerControl.ReferenceWidth = brush.BrushClass.TemplateWidth * brush.TileWidth + 1;
_layerControl.ReferenceHeight = brush.BrushClass.TemplateHeight * brush.TileHeight + 1;
_layer = new MultiTileGridLayer("Default", brush.TileWidth, brush.TileHeight, brush.BrushClass.TemplateWidth, brush.BrushClass.TemplateHeight);
for (int i = 0; i < brush.BrushClass.SlotCount; i++)
{
LocatedTile tile = brush.GetLocatedTile(i);
if (tile.Tile != null)
{
_layer.AddTile(tile.X, tile.Y, tile.Tile);
}
}
_rootLayer.Layers.Clear();
_rootLayer.Layers.Add(new TileGridLayerPresenter(_layerContext, _layer));
_rootLayer.Layers.Add(new LocalRenderLayerPresenter(new OverlayRenderCore(this)));
_rootLayer.Layers.Add(new GridLayerPresenter()
{
GridSpacingX = brush.TileWidth,
GridSpacingY = brush.TileHeight,
});
_nameField.Text = brush.Name;
_brush = brush;
SelectCurrentPrototype();
SelectCurrentTileSize();
}
public FloatTileSelectionCommand(MultiTileGridLayer source, ITileSelectionLayer selectLayer)
{
_tileSource = source;
_command = new TileReplace2DCommand(source);
_selectLayer = selectLayer;
}
public void RenamePoolByProperty1()
{
Layer layer = new MultiTileGridLayer("layer", 16, 16, 16, 16);
Property nameProperty = layer.LookupProperty("Name");
RenameLayer(layer, nameProperty);
}
public void CreateTileLayer()
{
TileLayer layer = new MultiTileGridLayer("layer", 16, 24, 30, 50);
Assert.AreEqual(16, layer.TileWidth);
Assert.AreEqual(24, layer.TileHeight);
}
public void RenamePoolByProperty2()
{
Layer layer = new MultiTileGridLayer("layer", 16, 16, 16, 16);
Property nameProperty = layer.PredefinedProperties["Name"];
RenameLayer(layer, nameProperty);
}
public void AddTiles(MultiTileGridLayer layer, IEnumerable <TileCoord> tileLocations)
{
foreach (TileCoord coord in tileLocations)
{
AddTile(layer, coord);
}
}
public void AddTileOutOfBounds()
{
TileGridLayer layer = new MultiTileGridLayer("tiles", 16, 16, 10, 10);
try {
layer.AddTile(-1, 2, _tile1);
Assert.Fail();
}
catch { }
try {
layer.AddTile(2, -1, _tile1);
Assert.Fail();
}
catch { }
try {
layer.AddTile(10, 8, _tile1);
Assert.Fail();
}
catch { }
try {
layer.AddTile(8, 10, _tile1);
Assert.Fail();
}
catch { }
}
private void InitializeBrush(StaticTileBrush brush)
{
int tilesW = brush.TilesWide + 12;
int tilesH = brush.TilesHigh + 12;
_layerControl.ReferenceWidth = tilesW * brush.TileWidth + 1;
_layerControl.ReferenceHeight = tilesH * brush.TileHeight + 1;
_layer = new MultiTileGridLayer("Default", brush.TileWidth, brush.TileHeight, tilesW, tilesH);
foreach (LocatedTile tile in brush.Tiles)
{
if (tile.Tile != null)
{
_layer.AddTile(tile.X, tile.Y, tile.Tile);
}
}
_rootLayer.Layers.Clear();
_rootLayer.Layers.Add(new TileGridLayerPresenter(_layerContext, _layer));
_rootLayer.Layers.Add(new GridLayerPresenter()
{
GridSpacingX = brush.TileWidth,
GridSpacingY = brush.TileHeight,
});
_nameField.Text = brush.Name;
_brush = brush;
SelectCurrentTileSize();
}
private TileGridLayer ProcessTileLayer(TileGridLayer layer, TilePool layerTilePool, Dictionary <Guid, Guid> tileUidMap)
{
MultiTileGridLayer outLayer = new MultiTileGridLayer(layer.Name, layer.TileWidth, layer.TileHeight, layer.TilesWide, layer.TilesHigh)
{
IsVisible = layer.IsVisible,
Opacity = layer.Opacity,
RasterMode = layer.RasterMode,
};
foreach (Property prop in layer.PropertyManager.CustomProperties)
{
outLayer.PropertyManager.CustomProperties.Add(prop);
}
foreach (LocatedTile tile in layer.Tiles)
{
Guid tileUid;
if (!tileUidMap.TryGetValue(tile.Tile.Uid, out tileUid))
{
Tile mappedTile = layerTilePool.Tiles.Add(tile.Tile.Pool.Tiles.GetTileTexture(tile.Tile.Uid));
tileUidMap[tile.Tile.Uid] = mappedTile.Uid;
tileUid = mappedTile.Uid;
foreach (Property prop in tile.Tile.PropertyManager.CustomProperties)
{
mappedTile.PropertyManager.CustomProperties.Add(prop);
}
}
outLayer.AddTile(tile.X, tile.Y, layerTilePool.Tiles[tileUid]);
}
return(outLayer);
}
public TileReplace2DCommand(MultiTileGridLayer source, Dictionary <TileCoord, TileStack> tileData)
: this(source)
{
foreach (KeyValuePair <TileCoord, TileStack> kv in tileData)
{
_tiles[kv.Key] = new TileRecord(_tileSource[kv.Key], kv.Value);
}
}
public void CloneTileLayer()
{
TileLayer layer = new MultiTileGridLayer("layer", 16, 24, 30, 50);
TileLayer layer2 = layer.Clone() as TileLayer;
Assert.AreEqual(16, layer2.TileWidth);
Assert.AreEqual(24, layer2.TileHeight);
}
public void LayerOpacityLowRange()
{
Layer layer = new MultiTileGridLayer("layer", 16, 16, 16, 16);
layer.Opacity = -0.5f;
Assert.AreEqual(0f, layer.Opacity);
}
public void LayerOpacityHighRange()
{
Layer layer = new MultiTileGridLayer("layer", 16, 16, 16, 16);
layer.Opacity = 1.5f;
Assert.AreEqual(1.0f, layer.Opacity);
}
public void AddTiles(MultiTileGridLayer layer, Rectangle tileRegion)
{
for (int y = tileRegion.Top; y < tileRegion.Bottom; y++)
{
for (int x = tileRegion.Left; x < tileRegion.Right; x++)
{
AddTile(layer, new TileCoord(x, y));
}
}
}
private void ApplyNew()
{
_layer = new MultiTileGridLayer(
_nameField.Text.Trim(),
(int)_tileWidthField.Value,
(int)_tileHeightField.Value,
_level);
_layer.Opacity = (float)_opacityField.Value;
_layer.GridColor = new Treefrog.Framework.Imaging.Color(_gridColorButton.Color.R, _gridColorButton.Color.G, _gridColorButton.Color.B, 128);
}
public TileEraseTool(CommandHistory history, MultiTileGridLayer layer, ObservableCollection <Annotation> annots)
: base(history, layer)
{
_annots = annots;
_previewMarker = new SelectionAnnot(new Point(0, 0))
{
Fill = new SolidColorBrush(new Color(192, 0, 0, 128)),
};
_annots.Add(_previewMarker);
}
private void AddTile(MultiTileGridLayer layer, TileCoord location)
{
if (!_tiles.ContainsKey(location))
{
TileStack stack = layer.TileStacksAt(location);
if (!TileStack.NullOrEmpty(stack))
{
_tiles.Add(location, stack);
}
_tileAnnot.AddTileLocation(location);
}
}
public void CreateLayer()
{
TileGridLayer layer = new MultiTileGridLayer("tiles", 16, 24, 10, 20);
Assert.AreEqual(16, layer.TileWidth);
Assert.AreEqual(24, layer.TileHeight);
Assert.AreEqual(10, layer.TilesWide);
Assert.AreEqual(20, layer.TilesHigh);
Assert.AreEqual(16 * 10, layer.LayerWidth);
Assert.AreEqual(24 * 20, layer.LayerHeight);
Assert.IsTrue(layer.IsResizable);
}
public void AddProperty()
{
Layer layer = new MultiTileGridLayer("layer", 16, 16, 16, 16);
AttachEvents(layer);
Property prop = new StringProperty("author", "Justin");
layer.CustomProperties.Add(prop);
Assert.AreEqual(EventFlags.Modified, _eventsFired);
}
public void ChangeLayerVisibility()
{
Layer layer = new MultiTileGridLayer("layer", 16, 16, 16, 16);
AttachEvents(layer);
Assert.AreEqual(true, layer.IsVisible);
layer.IsVisible = false;
Assert.AreEqual(EventFlags.VisibilityChanged | EventFlags.Modified, _eventsFired);
Assert.AreEqual(false, layer.IsVisible);
}
public void ChangeLayerVisibiliityProperty()
{
Layer layer = new MultiTileGridLayer("layer", 16, 16, 16, 16);
AttachEvents(layer);
Assert.AreEqual(true, layer.IsVisible);
layer.PredefinedProperties["Visible"].Parse("false");
Assert.AreEqual(EventFlags.VisibilityChanged | EventFlags.Modified, _eventsFired);
Assert.AreEqual(false, layer.IsVisible);
}
public void GetTilesAtLocation()
{
TileGridLayer layer = new MultiTileGridLayer("tiles", 16, 16, 10, 10);
layer.AddTile(2, 3, _tile1);
layer.AddTile(6, 7, _tile2);
Assert.AreEqual(1, layer.TilesAt(new TileCoord(2, 3)).Count());
Assert.AreEqual(0, layer.TilesAt(new TileCoord(1, 3)).Count());
Assert.AreEqual(0, layer.TilesAt(new TileCoord(3, 3)).Count());
Assert.AreEqual(0, layer.TilesAt(new TileCoord(1, 2)).Count());
Assert.AreEqual(0, layer.TilesAt(new TileCoord(1, 4)).Count());
}
public void ChangeLayerOpacity()
{
Layer layer = new MultiTileGridLayer("layer", 16, 16, 16, 16);
AttachEvents(layer);
Assert.AreEqual(1f, layer.Opacity);
layer.Opacity = 0.5f;
Assert.AreEqual(EventFlags.OpacityChanged | EventFlags.Modified, _eventsFired);
Assert.AreEqual(0.5f, layer.Opacity);
}
public void ChangeLayerOpacityProperty()
{
Layer layer = new MultiTileGridLayer("layer", 16, 16, 16, 16);
AttachEvents(layer);
Assert.AreEqual(1f, layer.Opacity);
layer.PredefinedProperties["Opacity"].Parse("0.5");
Assert.AreEqual(EventFlags.OpacityChanged | EventFlags.Modified, _eventsFired);
Assert.AreEqual(0.5f, layer.Opacity);
}
public void GetTilesInRegion()
{
TileGridLayer layer = new MultiTileGridLayer("tiles", 16, 16, 10, 10);
layer.AddTile(2, 3, _tile1);
layer.AddTile(6, 7, _tile2);
Assert.AreEqual(2, layer.TilesAt(new Rectangle(2, 2, 5, 6)).Count());
Assert.AreEqual(1, layer.TilesAt(new Rectangle(3, 2, 5, 6)).Count());
Assert.AreEqual(1, layer.TilesAt(new Rectangle(2, 4, 5, 6)).Count());
Assert.AreEqual(1, layer.TilesAt(new Rectangle(2, 2, 4, 6)).Count());
Assert.AreEqual(1, layer.TilesAt(new Rectangle(2, 2, 5, 5)).Count());
Assert.AreEqual(0, layer.TilesAt(new Rectangle(3, 2, 5, 5)).Count());
}
public TileLayerForm(MultiTileGridLayer layer)
{
InitializeForm();
Text = "Edit Tile Layer";
_layer = layer;
_nameField.Text = _layer.Name;
_opacityField.Value = (decimal)_layer.Opacity;
_tileWidthField.Value = _layer.TileWidth;
_tileHeightField.Value = _layer.TileHeight;
_gridColorButton.Color = Color.FromArgb(255, _layer.GridColor.R, _layer.GridColor.G, _layer.GridColor.B);
_tileHeightField.Enabled = false;
_tileWidthField.Enabled = false;
_validateController.Validate();
}
public void AddTile()
{
TileGridLayer layer = new MultiTileGridLayer("tiles", 16, 16, 10, 10);
AttachEvents(layer);
layer.TileAdded += (s, e) =>
{
Assert.AreEqual(2, e.X);
Assert.AreEqual(4, e.Y);
Assert.AreSame(_tile1, e.Tile);
Assert.AreEqual(1, layer.Tiles.Count());
Assert.AreEqual(1, layer.TilesAt(new TileCoord(2, 4)).Count());
};
layer.AddTile(2, 4, _tile1);
Assert.AreEqual(EventFlags.TileAdded | EventFlags.Modified, _eventsFired);
}
public void CloneLayerTest()
{
Layer layer = new MultiTileGridLayer("layer", 16, 16, 16, 16);
layer.Opacity = 0.5f;
layer.IsVisible = false;
Property prop = new StringProperty("author", "Justin");
layer.CustomProperties.Add(prop);
Layer layer2 = layer.Clone() as Layer;
Assert.AreEqual(layer.Opacity, layer2.Opacity);
Assert.AreEqual(layer.IsVisible, layer2.IsVisible);
Assert.AreEqual(1, layer2.CustomProperties.Count);
Assert.AreNotSame(prop, layer2.CustomProperties["author"]);
Assert.AreEqual("Justin", layer2.CustomProperties["author"].ToString());
}
private List <TilePool> TilePoolsByLevel(Level level)
{
List <TilePool> pools = new List <TilePool>();
foreach (Layer layer in level.Layers)
{
MultiTileGridLayer tileLayer = layer as MultiTileGridLayer;
if (tileLayer != null)
{
foreach (LocatedTile t in tileLayer.Tiles)
{
if (!pools.Contains(t.Tile.Pool))
{
pools.Add(t.Tile.Pool);
}
}
}
}
return(pools);
}
