void btnOK_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(tbTilesetName.Text))
{
MessageBox.Show("You must enter a name for the tileset.");
return;
}
if (string.IsNullOrEmpty(tbTilesetImage.Text))
{
MessageBox.Show("You must select an image for the tileset.");
return;
}
int tileWidth = 0;
int tileHeight = 0;
int tilesWide = 0;
int tilesHigh = 0;
if (!int.TryParse(mtbTileWidth.Text, out tileWidth))
{
MessageBox.Show("Tile width must be an integer value.");
return;
}
else if (tileWidth < 1)
{
MessageBox.Show("Tile width must me greater than zero.");
return;
}
if (!int.TryParse(mtbTileHeight.Text, out tileHeight))
{
MessageBox.Show("Tile height must be an integer value.");
return;
}
else if (tileHeight < 1)
{
MessageBox.Show("Tile height must be greater than zero.");
return;
}
Image tileSet = (Image)Bitmap.FromFile(tbTilesetImage.Text);
tilesWide = tileSet.Width / tileWidth;
tilesHigh = tileSet.Height / tileHeight;
tilesetData = new TilesetData
{
TilesetName = tbTilesetName.Text,
TilesetImageName = tbTilesetImage.Text,
TileWidthInPixels = tileWidth,
TileHeightInPixels = tileHeight,
TilesWide = tilesWide,
TilesHigh = tilesHigh
};
okPressed = true;
this.Close();
}
private static MapData ReadMapDataFromTMXFile(XmlDocument xmlDocument)
{
var mapData = new MapData();
//read metadata
var xmlData = xmlDocument.DocumentElement.SelectSingleNode("/map");
if (xmlData == null)
{
return(null);
}
if (!int.TryParse(xmlData.Attributes["width"].Value.Trim(), out mapData.width))
{
return(null);
}
if (!int.TryParse(xmlData.Attributes["height"].Value.Trim(), out mapData.height))
{
return(null);
}
var tilesetsXMLData = xmlDocument.DocumentElement.SelectNodes("/map/tileset");
for (var i = 0; i < tilesetsXMLData.Count; i++)
{
if (mapData.tilesetData == null)
{
mapData.tilesetData = new List <TilesetData>();
}
var tilesetData = new TilesetData();
tilesetData.firstgid = int.Parse(tilesetsXMLData[i].Attributes["firstgid"].Value.Trim());
tilesetData.prefix = tilesetsXMLData[i].Attributes["name"].Value.Trim();
tilesetData.tilecount = int.Parse(tilesetsXMLData[i].Attributes["tilecount"].Value.Trim());
mapData.tilesetData.Add(tilesetData);
}
//read tile map data
var dataNode = xmlDocument.DocumentElement.SelectSingleNode("/map/layer[@name='Map']/data");
var tiles = dataNode.InnerText.Split(',');
var index = 0;
mapData.data = new int[mapData.width][];
for (var i = 0; i < mapData.width; i++)
{
mapData.data[i] = new int[mapData.height];
for (var j = 0; j < mapData.height; j++)
{
mapData.data[i][j] = int.Parse(tiles[index].Trim());
index++;
}
}
return(mapData);
}
private void SetTileSet(TilesetData set)
{
(CurrentTileset = set).LoadImages(WorkingDirectory);
pnlPossibleTiles.Controls.Clear();
for (int i = 0; i < set.Tiles.Count; i++)
{
PictureBox tileButton = new PictureBox();
tileButton.Width = 16;
tileButton.Height = 16;
tileButton.Left = 16 * (i % 6);
tileButton.Top = 16 * (i / 6);
set.Tiles[i].Image.CurrentPalette = set.Tiles[i].Palette == 1 ? set.Palette1 : set.Palette2;
tileButton.Image = set.Tiles[i].Image.Target;
tileButton.Tag = i;
tileButton.Click += btnTileButton_Click;
tileButton.ResizeByZoom();
pnlPossibleTiles.Controls.Add(tileButton);
tileButton.FixZoom();
}
if (Tiles != null)
{
Render();
UpdatePreview();
}
}
public static List <TiledMapLayer> BuildLayers(MapData2D map, TilesetData tileset, ref int nextLayerId)
{
var underlayId = nextLayerId++;
var overlayId = nextLayerId++;
return(new()
{
new()
{
Id = underlayId,
Name = LayerName.Underlay,
Width = map.Width,
Height = map.Height,
Data = new LayerData {
Encoding = "csv", Content = BuildCsvData(map, tileset, false)
}
},
new()
{
Id = overlayId,
Name = LayerName.Overlay,
Width = map.Width,
Height = map.Height,
Data = new LayerData {
Encoding = "csv", Content = BuildCsvData(map, tileset, true)
}
}
});
}
public static Tileset FromAlbion(TilesetData tileset, Tilemap2DProperties properties)
{
if (tileset == null)
{
throw new ArgumentNullException(nameof(tileset));
}
if (properties == null)
{
throw new ArgumentNullException(nameof(properties));
}
List <Tile> tiles =
tileset.Tiles
.Where(x => !x.IsBlank)
.Select(x =>
TileMapping.BuildTile(
tileset.Id.Id,
x.Index,
x.FrameCount > 0 ? x.ImageNumber : null,
TileMapping.BuildTileProperties(x),
properties))
.ToList();
// Add tiles for the extra frames of animated tiles
int nextId = tileset.Tiles[^ 1].Index + 1;
public MapRenderable2D(MapData2D mapData, ITexture tileset, TilesetData tileData) : base(Handlers)
{
_mapData = mapData;
_tileset = tileset;
_tileData = tileData;
_tileset.GetSubImageDetails(0, out var tileSize, out _, out _, out _);
TileSize = tileSize;
var underlay = new SpriteInstanceData[_mapData.Width * _mapData.Height];
var overlay = new SpriteInstanceData[_mapData.Width * _mapData.Height];
_underlay = new MultiSprite(new SpriteKey(
_tileset,
(int)DrawLayer.Underlay,
underlay[0].Flags))
{
Instances = underlay.ToArray()
};
_overlay = new MultiSprite(new SpriteKey(
_tileset,
(int)DrawLayer.Overlay3,
overlay[0].Flags))
{
Instances = overlay.ToArray()
};
}
public LogicalMap2D(IAssetManager assetManager, MapData2D mapData,
IList <MapChange> tempChanges,
IList <MapChange> permChanges)
{
_mapData = mapData ?? throw new ArgumentNullException(nameof(mapData));
_tempChanges = tempChanges ?? throw new ArgumentNullException(nameof(tempChanges));
_permChanges = permChanges ?? throw new ArgumentNullException(nameof(permChanges));
_tileData = assetManager.LoadTileData(_mapData.TilesetId);
_blockList = assetManager.LoadBlockList((BlockListId)_mapData.TilesetId); // Note: Assuming a 1:1 correspondence between blocklist and tileset ids.
UseSmallSprites = _tileData.UseSmallGraphics;
// Clear out temp changes for other maps
for (int i = 0; i < tempChanges.Count;)
{
if (_tempChanges[i].MapId != mapData.Id)
{
_tempChanges.RemoveAt(i);
}
else
{
i++;
}
}
// Replay any changes for this map
foreach (var change in permChanges.Where(x => x.MapId == mapData.Id))
{
ApplyChange(change.X, change.Y, change.ChangeType, change.Value, change.Unk3);
}
foreach (var change in tempChanges)
{
ApplyChange(change.X, change.Y, change.ChangeType, change.Value, change.Unk3);
}
}
public static TileMap AddTilemap(TilemapData data, TilesetData setting)
{
if (TILEMAPS.ContainsKey(data.Name))
{
return(TILEMAPS[data.Name]);
}
string[,] tiles = new string[data.Map.GetLength(0), data.Map.GetLength(1)];
for (int y = 0; y < data.Map.GetLength(0); y++)
{
for (int x = 0; x < data.Map.GetLength(1); x++)
{
if (setting.Tiles.ContainsKey(data.Map[y, x]))
{
tiles[y, x] = $@"C\Tiles\{setting.Tiles[data.Map[y, x]]}";
}
else
{
tiles[y, x] = @"C\Tiles\empty";
}
}
}
TileMap ret = new TileMap(data.Name, tiles);
TILEMAPS.Add(data.Name, ret);
return(ret);
}
public MapRenderable2D(MapData2D mapData, ITexture tileset, TilesetData tileData) : base(Handlers)
{
_mapData = mapData;
_tileset = tileset;
_tileData = tileData;
_tileset.GetSubImageDetails(0, out var tileSize, out _, out _, out _);
TileSize = tileSize;
}
void newTilesetToolStripMenuItem_Click(object sender, EventArgs e)
{
using (FormNewTileset frmNewTileset = new FormNewTileset())
{
frmNewTileset.ShowDialog();
if (frmNewTileset.OKPressed)
{
TilesetData data = frmNewTileset.TilesetData;
try
{
GDIImage image = (GDIImage)GDIBitmap.FromFile(data.TilesetImageName);
tileSetImages.Add(image);
Stream stream = new FileStream(data.TilesetImageName, FileMode.Open,
FileAccess.Read);
Texture2D texture = Texture2D.FromStream(GraphicsDevice, stream);
Tileset tileset = new Tileset(
texture,
data.TilesWide,
data.TilesHigh,
data.TileWidthInPixels,
data.TileHeightInPixels);
tileSets.Add(tileset);
tileSetData.Add(data);
if (map != null)
{
map.AddTileset(tileset);
}
stream.Close();
stream.Dispose();
}
catch (Exception ex)
{
MessageBox.Show("Error reading file.\n" + ex.Message, "Error reading image");
return;
}
lbTileset.Items.Add(data.TilesetName);
if (lbTileset.SelectedItem == null)
{
lbTileset.SelectedIndex = 0;
}
mapLayerToolStripMenuItem.Enabled = true;
}
}
}
private void AreaOpened(AreaDataObservable area)
{
TilesetData tileset = _moduleDataService.Load <TilesetData>(area.TilesetGlobalID);
ResourceItemData data = _resourceService.GetResourceByName(ResourceType.Tileset, tileset.ResourceName);
ActiveTilesetImage = BitmapImageHelpers.LoadFromBytes(data.Data);
ActiveTilesetImageWidth = ActiveTilesetImage.Width;
ActiveTilesetImageHeight = ActiveTilesetImage.Height;
TileGridVisibility = Visibility.Visible;
}
public void HandleCustomProperties(UnityEngine.GameObject gameObject,
IDictionary <string, string> props)
{
if (props.ContainsKey("Areas"))
{
foreach (string areaName in props["Areas"].Split('|'))
{
string[] guids = AssetDatabase.FindAssets(areaName, new string[1] {
"Assets/Resources"
});
TilesetData data = null;
if (guids.Length == 0)
{
// create a MapConfig;
data = ScriptableObject.CreateInstance <TilesetData>();
data.SmallRooms = new List <string>();
data.LargeRooms = new List <string>();
AssetDatabase.CreateAsset(data, "Assets/Resources/" + areaName + ".asset");
}
else
{
// load the mapconfig and add this mapchunk to it.
data = AssetDatabase.LoadAssetAtPath <TilesetData>(AssetDatabase.GUIDToAssetPath(guids[0]));
}
if (props["IsLargeRoom"] == "true")
{
if (!data.LargeRooms.Contains(gameObject.name))
{
data.LargeRooms.Add(gameObject.name);
}
}
else
{
if (!data.SmallRooms.Contains(gameObject.name))
{
data.SmallRooms.Add(gameObject.name);
}
}
EditorUtility.SetDirty(data);
}
}
if (props.ContainsKey("Facing"))
{
gameObject.AddComponent <Door>();
Door door = gameObject.GetComponent <Door>();
door.facing = props["Facing"];
}
if (props.ContainsKey("SpawnerType"))
{
gameObject.name = props["SpawnerType"] + "Spawner";
}
}
private TilesetData TilesetDataFromUI(TilesetData data)
{
data.Name = txtName.Text;
data.Palette1 = plt1.Data;
data.Palette2 = plt2.Data;
data.Tiles = CurrentTiles.ConvertAll(a => a.Clone());
data.BattleBackgrounds = bblBattleBackgrounds.Datas;
CurrentFile = data.Name;
Dirty = false;
return(data);
}
public static TilesetData AddTilesetData(string name)
{
if (TILESETDATAS.ContainsKey(name))
{
return(TILESETDATAS[name]);
}
TilesetData load = Program.Content.Load <TilesetData>(name);
TILESETDATAS.Add(name, load);
return(load);
}
private void TilesetDataToUI(TilesetData data)
{
data.LoadImages(WorkingDirectory);
txtName.Text = data.Name;
plt1.Data = data.Palette1;
plt2.Data = data.Palette2;
CurrentTiles = data.Tiles.ConvertAll(a => a.Clone());
bblBattleBackgrounds.Datas = data.BattleBackgrounds;
SelectedIndex = -1;
Render();
CurrentFile = data.Name;
Dirty = false;
}
public static (Map, string) FromAlbionMap2D(
MapData2D map,
TilesetData tileset,
Tilemap2DProperties properties,
string tilesetPath,
Tileset npcTileset,
EventFormatter eventFormatter)
{
if (map == null)
{
throw new ArgumentNullException(nameof(map));
}
if (tileset == null)
{
throw new ArgumentNullException(nameof(tileset));
}
if (properties == null)
{
throw new ArgumentNullException(nameof(properties));
}
if (npcTileset == null)
{
throw new ArgumentNullException(nameof(npcTileset));
}
ushort blankTileIndex = 0;
int nextObjectId = 1;
int nextLayerId = 3; // 1 & 2 are always underlay & overlay.
npcTileset.GidOffset = tileset.Tiles.Count;
var(script, functionsByEventId) = BuildScript(map, eventFormatter);
var result = new Map
{
TiledVersion = "1.4.2",
Version = "1.4",
Width = map.Width,
Height = map.Height,
TileWidth = properties.TileWidth,
TileHeight = properties.TileHeight,
Infinite = 0,
NextLayerId = 5, // max(layer or objectgroup id) + 1
Orientation = "orthogonal",
RenderOrder = "right-down",
BackgroundColor = "#000000",
Properties = BuildMapProperties(map),
Tilesets = new List <MapTileset>
{
new() { FirstGid = 0, Source = tilesetPath, },
new() { FirstGid = npcTileset.GidOffset, Source = npcTileset.Filename }
},
/* This function is called when the OK button is clicked. It creates the new tileset using the user input. */
void btnOK_Click(object sender, EventArgs e)
{
/* First, the two text boxes are checked to make sure they contain text, using the string.IsNullOrEmpty() function.
* If one of the text boxes is empty, then a message box is shown to the user telling them they need to write something. */
if (string.IsNullOrEmpty(tbTilesetName.Text))
{
MessageBox.Show("You must enter a name for the tileset.");
return;
}
if (string.IsNullOrEmpty(tbTilesetImage.Text))
{
MessageBox.Show("You must choose a tileset image.");
return;
}
/* The tileWidth and tileHeight fields are initialized with zero as the default value.
* The function tries to convert the contents of the tile width and height text boxes into integers using TryParse().
* It also checks if either of the values are less than one.
* If either of these fail, then a message box is displayed informing the user. */
int tileWidth = 0;
int tileHeight = 0;
if (!int.TryParse(mtbTileWidth.Text, out tileWidth) || tileWidth < 1)
{
MessageBox.Show("Tile Width must be 1 or more.");
return;
}
if (!int.TryParse(mtbTileHeight.Text, out tileHeight) || tileHeight < 1)
{
MessageBox.Show("Tile Height must be 1 or more.");
return;
}
/* Next, the function loads in the actual image associated with the tileset as a System.Drawing.Image, from the file name in the tileset image text box.
* The tilesWide and tilesHigh fields for the tileset are calculated by dividing the image's width/height by the width/height of each individual tile. */
SysImage tilesetImage = SysImage.FromFile(tbTilesetImage.Text);
/* The new TilesetData is initialized and set with the name and image path from the text boxes in the form.
* The tile width and height are set from the numbers entered into the form.
* The number of tiles wide/high in the tileset is calculated by dividing the tileset image width/height by the individual tile width/height.
* Finally, since the form has finished processing the new tileset, formFinished is set to true. */
tilesetData = new TilesetData();
tilesetData.TilesetName = tbTilesetName.Text;
tilesetData.TilesetImageName = tbTilesetImage.Text;
tilesetData.TileWidthInPixels = tileWidth;
tilesetData.TileHeightInPixels = tileHeight;
tilesetData.TilesWide = tilesetImage.Width / tileWidth;
tilesetData.TilesHigh = tilesetImage.Height / tileHeight;
formFinished = true;
Close();
}
public LogicalMap2D(
IAssetManager assetManager,
MapData2D mapData,
MapChangeCollection tempChanges,
MapChangeCollection permChanges) : base(mapData, tempChanges, permChanges)
{
if (assetManager == null)
{
throw new ArgumentNullException(nameof(assetManager));
}
_mapData = mapData ?? throw new ArgumentNullException(nameof(mapData));
_tileData = assetManager.LoadTileData(_mapData.TilesetId);
_blockList = assetManager.LoadBlockList(_mapData.TilesetId.ToBlockList());
UseSmallSprites = _tileData.UseSmallGraphics;
}
public override bool BushFlag()
{
MapData data = MapComponent.Instance.GetMapInstance().GetMapData();
if (data == null)
{
return(false);
}
for (int i = 0; i < 3; i++)
{
float x = _mapPlayer.GetPlayerPacket().RealX;
float y = _mapPlayer.GetPlayerPacket().RealY;
if ((x % 32) / 32f < 0.5)
{
x = (int)Math.Floor(x / 32);
}
else
{
x = (int)Math.Ceiling(x / 32);
}
if ((y % 32) / 32f < 0.3)
{
y = (int)Math.Floor(y / 32);
}
else
{
y = (int)Math.Ceiling(y / 32);
}
Tuple <int, int> tileInfo = data.GetTile(i, (int)x, (int)y);
if (tileInfo == null)
{
continue;
}
TilesetData.Tileset tileset = TilesetData.GetTileset(tileInfo.Item2);
if (tileset != null)
{
if (tileset.GetBushFlag(tileInfo.Item1))
{
return(true);
}
}
}
return(base.BushFlag());
}
public override bool BushFlag()
{
if (_mapEvent.Priority == RenderPriority.OnTop)
{
return(false);
}
MapData data = MapComponent.Instance.GetMapInstance().GetMapData();
for (int i = 0; i < 3; i++)
{
float x = _mapEvent.RealX;
float y = _mapEvent.RealY;
if ((x % 32) / 32f < 0.5)
{
x = (int)Math.Floor(x / 32);
}
else
{
x = (int)Math.Ceiling(x / 32);
}
if ((y % 32) / 32f < 0.3)
{
y = (int)Math.Floor(y / 32);
}
else
{
y = (int)Math.Ceiling(y / 32);
}
Tuple <int, int> tileInfo = data.GetTile(i, (int)x, (int)y);
if (tileInfo != null)
{
TilesetData.Tileset tileset = TilesetData.GetTileset(tileInfo.Item2);
if (tileset != null)
{
if (tileset.GetBushFlag(tileInfo.Item1))
{
return(true);
}
}
}
}
return(base.BushFlag());
}
public static Tileset FromTileset(TilesetData tileset, TilemapProperties properties)
{
if (tileset == null)
{
throw new ArgumentNullException(nameof(tileset));
}
if (properties == null)
{
throw new ArgumentNullException(nameof(properties));
}
// +1 to go from max index to count, then + another so we have a blank tile at the end.
int count = tileset.Tiles
.Where(x => x.ImageNumber != 0xffff)
.Max(x => x.ImageNumber + x.FrameCount - 1)
+ 2;
int columns = (properties.SheetWidth - 2 * properties.Margin) / (properties.TileWidth + properties.Spacing);
public override void Subscribed()
{
if (_mapData == null)
{
var assets = Resolve <IAssetManager>();
_mapData = assets.LoadMap2D(MapId);
var tileset = assets.LoadTexture((IconGraphicsId)_mapData.TilesetId);
_tileData = assets.LoadTileData((IconDataId)_mapData.TilesetId);
_renderable = new MapRenderable2D(_mapData, tileset, _tileData);
_useSmallSprites = _tileData.UseSmallGraphics;
Exchange.Attach(_renderable);
Children.Add(_renderable);
foreach (var npc in _mapData.Npcs)
{
IComponent sprite =
_useSmallSprites
? new SmallNpc((SmallNpcId)npc.ObjectNumber, npc.Waypoints) as IComponent
: new LargeNpc((LargeNpcId)npc.ObjectNumber, npc.Waypoints);
Exchange.Attach(sprite);
Children.Add(sprite);
}
IMovement partyMovement = new PartyMovement(_useSmallSprites, Vector2.Zero, PartyMovement.Direction.Right); // TODO: Initial position.
Exchange.Register(partyMovement);
Children.Add(partyMovement);
var state = Resolve <IGameState>();
foreach (var player in state.Party.StatusBarOrder)
{
player.GetPosition = () => partyMovement.GetPositionHistory(player.Id).Item1;
var playerSprite = _useSmallSprites
? (IComponent) new SmallPlayer(player.Id, (SmallPartyGraphicsId)player.Id, () => partyMovement.GetPositionHistory(player.Id)) // TODO: Use a function to translate logical to sprite id
: new LargePlayer(player.Id, (LargePartyGraphicsId)player.Id, () => partyMovement.GetPositionHistory(player.Id)); // TODO: Use a function to translate logical to sprite id
Exchange.Attach(playerSprite);
Children.Add(playerSprite);
}
}
Raise(new SetClearColourEvent(0, 0, 0));
}
static string BuildCsvData(MapData2D map, TilesetData tileset, bool useOverlay)
{
var sb = new StringBuilder();
for (int j = 0; j < map.Height; j++)
{
for (int i = 0; i < map.Width; i++)
{
int index = j * map.Width + i;
var tileIndex = useOverlay ? map.Overlay[index] : map.Underlay[index];
var tile = tileset.Tiles[tileIndex];
sb.Append(tile.IsBlank ? BlankTileIndex : tileIndex);
sb.Append(',');
}
sb.AppendLine();
}
return(sb.ToString(0, sb.Length - (Environment.NewLine.Length + 1)));
}
public TestTilemap(ITextureBuilderFont font, ITextureBuilderFont bigFont)
{
var tiles = new List <IReadOnlyTexture <byte> >
{
Constants.T.FillAll(Constants.CBlack1).Texture,
Constants.T.FillAll(Constants.CBlack1).Texture,
Constants.T.FillAll(Constants.CGrey12).Texture,
};
Tileset = new TilesetData(UAlbion.Base.Tileset.Toronto)
{
UseSmallGraphics = false
};
Tileset.Tiles.Add(new(Tileset.Tiles.Count, 1, TileType.Normal, TileLayer.Normal));
BlankOffset = Tileset.Tiles.Count;
Tileset.Tiles.Add(new(Tileset.Tiles.Count, 1, TileType.Normal, TileLayer.Normal));
SolidOffset = Tileset.Tiles.Count;
Tileset.Tiles.Add(new(Tileset.Tiles.Count, 2, TileType.Normal, TileLayer.Normal)
{ Collision = Passability.Solid });
public LogicalMap2D(
IAssetManager assetManager,
MapData2D mapData,
MapChangeCollection tempChanges,
MapChangeCollection permChanges)
{
if (assetManager == null)
{
throw new ArgumentNullException(nameof(assetManager));
}
_mapData = mapData ?? throw new ArgumentNullException(nameof(mapData));
_tempChanges = tempChanges ?? throw new ArgumentNullException(nameof(tempChanges));
_permChanges = permChanges ?? throw new ArgumentNullException(nameof(permChanges));
_tileData = assetManager.LoadTileData(_mapData.TilesetId);
_blockList = assetManager.LoadBlockList(_mapData.TilesetId.ToBlockList());
UseSmallSprites = _tileData.UseSmallGraphics;
// Clear out temp changes for other maps
for (int i = 0; i < tempChanges.Count;)
{
if (_tempChanges[i].MapId != mapData.Id)
{
_tempChanges.RemoveAt(i);
}
else
{
i++;
}
}
// Replay any changes for this map
foreach (var change in permChanges.Where(x => x.MapId == mapData.Id))
{
ApplyChange(change.X, change.Y, change.ChangeType, change.Value);
}
foreach (var change in tempChanges)
{
ApplyChange(change.X, change.Y, change.ChangeType, change.Value);
}
}
public object Load(BinaryReader br, long streamLength, string name, AssetInfo config)
{
var td = new TilesetData();
td.UseSmallGraphics = config.UseSmallGraphics ?? false;
var validPassabilities = typeof(TilesetData.Passability).GetEnumValues().Cast <int>().ToList();
var validLayers = typeof(TilesetData.TileLayer).GetEnumValues().Cast <byte>().ToList();
var validTypes = typeof(TilesetData.TileType).GetEnumValues().Cast <byte>().ToList();
int tileCount = (int)(streamLength / 8);
for (int i = 0; i < tileCount; i++)
{
var t = new TilesetData.TileData {
TileNumber = i
};
byte firstByte = br.ReadByte(); // 0
t.Layer = (TilesetData.TileLayer)(firstByte >> 4); // Upper nibble of first byte (0h)
Debug.Assert(validLayers.Contains((byte)t.Layer), "Unexpected tile layer found");
t.Type = (TilesetData.TileType)(firstByte & 0xf); // Lower nibble of first byte (0l)
Debug.Assert(validTypes.Contains((byte)t.Type), "Unexpected tile type found");
t.Collision = (TilesetData.Passability)br.ReadByte(); // 1
Debug.Assert(validPassabilities.Contains((int)t.Collision));
t.Flags = (TilesetData.TileFlags)br.ReadUInt16(); // 2
Debug.Assert((t.Flags & TilesetData.TileFlags.UnusedMask) == 0, "Unused flags set");
t.ImageNumber = br.ReadUInt16(); // 4
t.FrameCount = br.ReadByte(); // 6
t.Unk7 = br.ReadByte(); // 7
td.Tiles.Add(t);
}
return(td);
}
public void SerializerConfig_TilesetData_ShouldBeEqual()
{
TilesetData data = new TilesetData
{
Name = "it's a name",
Resref = "it's a resref",
Comment = "it's a comment",
Description = "it's a description",
Tag = "it's a tag"
};
TilesetData result;
using (MemoryStream stream = new MemoryStream())
{
Serializer.Serialize(stream, data);
stream.Position = 0;
result = Serializer.Deserialize <TilesetData>(stream);
}
Assert.IsTrue(_compareLogic.Compare(data, result).AreEqual);
}
void GenerateTilemap()
{
if (meshObject.GetComponent <MeshFilter>() != null)
{
DestroyImmediate(meshObject.GetComponent <MeshFilter>());
mesh = null;
}
meshFilter = meshObject.AddComponent <MeshFilter>();
mesh = new Mesh();
if (meshObject.GetComponent <MeshCollider>() == null)
{
if (_generateMeshCollider)
{
meshCollider = meshObject.AddComponent <MeshCollider>();
}
}
else if (!_generateMeshCollider)
{
DestroyImmediate(meshObject.GetComponent <MeshCollider>());
meshCollider = null;
}
else if (_generateMeshCollider)
{
meshCollider = meshObject.GetComponent <MeshCollider>();
}
if (meshObject.GetComponent <MeshRenderer>() == null)
{
meshRenderer = meshObject.AddComponent <MeshRenderer>();
}
else
{
meshRenderer = meshObject.GetComponent <MeshRenderer>();
}
List <Vector3> vertices = new List <Vector3>();
List <Vector2> uvs = new List <Vector2>();
// Tileset id, Triangles List (each tileset = submesh)
Dictionary <int, List <int> > submeshesTriangles = new Dictionary <int, List <int> >();
float actualZ = 0;
int triangleFaces = -1;
for (int layerIdx = 0; layerIdx < layers.Count; layerIdx++)
{
actualZ += _layerZ;
TilelayerData layer = layers[layerIdx];
for (int row = 1; row <= tilemapHeight; ++row)
{
for (int col = 0; col < tilemapWidth; ++col)
{
// Get GID
int gid = layer.gids[row - 1, col];
if (gid == 0)
{
continue;
}
// Get tileset for this gid
int tilesetId = tilesetIdToGid[gid];
TilesetData tileset = tilesets[tilesetId];
int textureTilesPerRow = tileset.tilesPerRow;
int firstGid = tileset.firstgid;
float textureWidth = tileset.imagewidth;
float textureHeight = tileset.imageheight;
if (!submeshesTriangles.ContainsKey(tilesetId))
{
submeshesTriangles.Add(tilesetId, new List <int>());
}
// Tile position
Vector3 pos0 = new Vector3(col * scaleX, (-(tileHeight * row - anchorY) * scale), 0);
Vector3 pos1 = pos0 + new Vector3(scaleX, scaleY, 0);
// Vertices
Vector3 p0 = new Vector3(pos0.x, pos0.y, actualZ);
Vector3 p1 = new Vector3(pos1.x, pos0.y, actualZ);
Vector3 p2 = new Vector3(pos0.x, pos1.y, actualZ);
Vector3 p3 = new Vector3(pos1.x, pos1.y, actualZ);
vertices.Add(p0);
vertices.Add(p1);
vertices.Add(p2);
vertices.Add(p3);
// Triangles
triangleFaces += 4;
submeshesTriangles[tilesetId].Add(triangleFaces - 3);
submeshesTriangles[tilesetId].Add(triangleFaces - 1);
submeshesTriangles[tilesetId].Add(triangleFaces - 2);
submeshesTriangles[tilesetId].Add(triangleFaces - 2);
submeshesTriangles[tilesetId].Add(triangleFaces - 1);
submeshesTriangles[tilesetId].Add(triangleFaces);
// UV
int equivalentGidFromFirstRow = gid - firstGid + 1;
int tilesRow = 1;
for (; equivalentGidFromFirstRow > (textureTilesPerRow); equivalentGidFromFirstRow -= (textureTilesPerRow))
{
tilesRow++;
}
float tileX = ((equivalentGidFromFirstRow - 1) * (tileWidth + tileset.spacing)) + tileset.margin;
float tileYBottomLeft = (((tileHeight + tileset.spacing) * tilesRow) - tileset.spacing) + tileset.margin;
float pixelMinX = textureWidth;
float pixelMinY = textureHeight;
if (tileX != 0f)
{
pixelMinX = tileX / pixelMinX;
}
if (tileYBottomLeft != 0f)
{
pixelMinY = tileYBottomLeft / pixelMinY;
}
Vector2 pixelMin = new Vector2(pixelMinX, 1.0f - pixelMinY);
Vector2 pixelDims = new Vector2((tileWidth / textureWidth), (tileHeight / textureHeight));
Vector2 min = pixelMin;
// Amount of UV's have to match the amount of verts
// And their winding.
// Fix gaps with eps: http://forum.unity3d.com/threads/41187-Web-demo-of-my-2D-platformer?p=263666&viewfull=1#post263666
float eps = BleedingOffset;
uvs.Add(min + new Vector2(pixelDims.x * 0.0f + eps, pixelDims.y * 0.0f + eps));
uvs.Add(min + new Vector2(pixelDims.x * 1.0f - eps, pixelDims.y * 0.0f + eps));
uvs.Add(min + new Vector2(pixelDims.x * 0.0f + eps, pixelDims.y * 1.0f - eps));
uvs.Add(min + new Vector2(pixelDims.x * 1.0f - eps, pixelDims.y * 1.0f - eps));
}
}
} // end iterate layers
mesh.vertices = vertices.ToArray();
mesh.uv = uvs.ToArray();
// Only one tileset, no need for more than one submesh
if (_amountTilesets == 1)
{
mesh.triangles = submeshesTriangles[0].ToArray();
}
// A submesh to each tileset
else
{
mesh.subMeshCount = _amountTilesets;
for (int tilesetId = 0; tilesetId < _amountTilesets; tilesetId++)
{
if (submeshesTriangles.ContainsKey(tilesetId))
{
mesh.SetTriangles(submeshesTriangles[tilesetId].ToArray(), tilesetId);
}
else
{
mesh.SetTriangles(new int[0], tilesetId);
}
}
}
meshFilter.mesh = mesh;
mesh.RecalculateNormals();
mesh.RecalculateBounds();
;
if (_generateMeshCollider)
{
meshCollider.sharedMesh = null;
meshCollider.sharedMesh = mesh;
}
meshRenderer.materials = TilesetsMaterials;
}
void ImportTiledXML()
{
if (LoadTiledXML())
{
if (_xml.DocumentElement.Name == "map")
{
tilemapWidth = System.Convert.ToInt32(_xml.DocumentElement.Attributes["width"].Value);
tilemapHeight = System.Convert.ToInt32(_xml.DocumentElement.Attributes["height"].Value);
tileWidth = System.Convert.ToInt32(_xml.DocumentElement.Attributes["tilewidth"].Value);
tileHeight = System.Convert.ToInt32(_xml.DocumentElement.Attributes["tileheight"].Value);
scaleX = tileWidth * scale;
scaleY = tileHeight * scale;
anchorX = 0;
anchorY = tileHeight;
XmlNodeList tilesetsNodes = _xml.DocumentElement.SelectNodes("tileset");
XmlNodeList layersNodes = _xml.DocumentElement.SelectNodes("layer");
XmlNode subNode = null;
XmlNode subSubNode = null;
tilesets = new List <TilesetData>();
layers = new List <TilelayerData>();
tilesetIdToGid = new Dictionary <int, int>();
for (int tilesetId = 0; tilesetId < tilesetsNodes.Count; ++tilesetId)
{
subNode = tilesetsNodes[tilesetId];
TilesetData tileset = new TilesetData();
tileset.name = subNode.Attributes["name"].Value;
tileset.firstgid = System.Convert.ToInt32(subNode.Attributes["firstgid"].Value);
tileset.tilewidth = System.Convert.ToInt32(subNode.Attributes["tilewidth"].Value);
tileset.tileheight = System.Convert.ToInt32(subNode.Attributes["tileheight"].Value);
if (subNode.Attributes["margin"] != null)
{
tileset.margin = System.Convert.ToInt32(subNode.Attributes["margin"].Value);
}
else
{
tileset.margin = 0;
}
if (subNode.Attributes["spacing"] != null)
{
tileset.spacing = System.Convert.ToInt32(subNode.Attributes["spacing"].Value);
}
else
{
tileset.spacing = 0;
}
subSubNode = subNode.SelectSingleNode("image");
tileset.imagesource = subSubNode.Attributes["source"].Value;
tileset.imagewidth = (float)System.Convert.ToDouble(subSubNode.Attributes["width"].Value);
tileset.imageheight = (float)System.Convert.ToDouble(subSubNode.Attributes["height"].Value);
tileset.tilesPerRow = (int)((tileset.imagewidth - tileset.margin * 2 + tileset.spacing) /
(tileset.tilewidth + tileset.spacing)
);
tileset.tilesPerColumn = (int)((tileset.imageheight - tileset.margin * 2 + tileset.spacing) /
(tileset.tileheight + tileset.spacing)
);
tileset.amountTiles = tileset.tilesPerRow * tileset.tilesPerColumn;
tilesets.Add(tileset);
// Map each gid of this tileset with the Tileset ID, so when building the tilemap
// mesh, we can easily grab the tileset related to the gid.
for (int gid = tileset.firstgid; gid <= (tileset.firstgid + tileset.amountTiles - 1); gid++)
{
tilesetIdToGid.Add(gid, tilesetId);
}
}
for (int layerId = 0; layerId < layersNodes.Count; ++layerId)
{
subNode = layersNodes[layerId];
TilelayerData layer = new TilelayerData();
layer.name = subNode.Attributes["name"].Value;
XmlNodeList gidsNodes = subNode.SelectNodes("data/tile");
int gidRow = 0;
int gidColumn = 0;
layer.gids = new int[tilemapWidth, tilemapHeight];
for (int gi = 0; gi < gidsNodes.Count; gi++)
{
layer.gids[gidRow, gidColumn] = System.Convert.ToInt32(gidsNodes[gi].Attributes["gid"].Value);
gidColumn++;
if ((gi + 1) % tilemapWidth == 0)
{
gidRow++;
gidColumn = 0;
}
}
layers.Add(layer);
}
_amountTilesets = tilesets.Count;
if (TilesetsTextures != null && TilesetsTextures.Length != _amountTilesets)
{
for (int i = 0; i < TilesetsMaterials.Length; i++)
{
if (TilesetsMaterials[i] != null)
{
DestroyImmediate(TilesetsMaterials[i]);
}
}
TilesetsTextures = null;
TilesetsMaterials = null;
}
if (TilesetsTextures == null)
{
TilesetsTextures = new Texture[_amountTilesets];
TilesetsMaterials = new Material[TilesetsTextures.Length];
}
}
}
}
public static void Dump(string baseDir, IAssetManager assets, ISet <AssetType> types, AssetId[] dumpIds)
{
var disposeList = new List <IDisposable>();
TextWriter Writer(string name)
{
var filename = Path.Combine(baseDir, "data", "exported", "json", name);
var directory = Path.GetDirectoryName(filename);
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
var stream = File.Open(filename, FileMode.Create);
var writer = new StreamWriter(stream);
disposeList.Add(writer);
disposeList.Add(stream);
return(writer);
}
void Flush()
{
foreach (var d in disposeList)
{
d.Dispose();
}
disposeList.Clear();
}
var settings = new JsonSerializerSettings
{
Formatting = Formatting.Indented,
DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate,
};
var s = JsonSerializer.Create(settings);
TextWriter tw;
if (types.Contains(AssetType.TilesetData))
{
foreach (var id in DumpUtil.All(AssetType.TilesetData, dumpIds))
{
TilesetData asset = assets.LoadTileData(id);
if (asset == null)
{
continue;
}
tw = Writer($"tilesets/tileset{id.Id}.json");
s.Serialize(tw, asset);
}
Flush();
}
if (types.Contains(AssetType.Labyrinth))
{
foreach (var id in DumpUtil.All(AssetType.Labyrinth, dumpIds))
{
LabyrinthData asset = assets.LoadLabyrinthData(id);
if (asset == null)
{
continue;
}
tw = Writer($"labdata/labyrinth{id.Id}.json");
s.Serialize(tw, asset);
}
Flush();
}
// string str = assets.LoadString(StringId id, GameLanguage language);
if (types.Contains(AssetType.Map))
{
foreach (var id in DumpUtil.All(AssetType.Map, dumpIds))
{
IMapData asset = assets.LoadMap(id);
if (asset == null)
{
continue;
}
tw = Writer($"maps/map{id.Id}_{id}.json");
s.Serialize(tw, asset);
}
Flush();
}
if (types.Contains(AssetType.Item))
{
tw = Writer("items.json");
s.Serialize(tw, DumpUtil.AllAssets(AssetType.Item, dumpIds, x => assets.LoadItem(x)));
Flush();
}
if (types.Contains(AssetType.PartyMember))
{
tw = Writer("party_members.json");
s.Serialize(tw, DumpUtil.AllAssets(AssetType.PartyMember, dumpIds, x => assets.LoadSheet(x)));
Flush();
}
if (types.Contains(AssetType.Npc))
{
tw = Writer("npcs.json");
s.Serialize(tw, DumpUtil.AllAssets(AssetType.Npc, dumpIds, x => assets.LoadSheet(x)));
Flush();
}
if (types.Contains(AssetType.Monster))
{
tw = Writer("monsters.json");
s.Serialize(tw, DumpUtil.AllAssets(AssetType.Monster, dumpIds, x => assets.LoadSheet(x)));
Flush();
}
if (types.Contains(AssetType.Chest))
{
tw = Writer("chests.json");
s.Serialize(tw, DumpUtil.AllAssets(AssetType.Chest, dumpIds, assets.LoadInventory));
Flush();
}
if (types.Contains(AssetType.Merchant))
{
tw = Writer("merchants.json");
s.Serialize(tw, DumpUtil.AllAssets(AssetType.Merchant, dumpIds, assets.LoadInventory));
Flush();
}
if (types.Contains(AssetType.BlockList))
{
foreach (var id in DumpUtil.All(AssetType.BlockList, dumpIds))
{
IList <Block> asset = assets.LoadBlockList(id);
if (asset == null)
{
continue;
}
tw = Writer($"blocks/blocklist{id.Id}.json");
s.Serialize(tw, asset);
}
Flush();
}
if (types.Contains(AssetType.EventSet))
{
tw = Writer("event_sets.json");
s.Serialize(tw, DumpUtil.AllAssets(AssetType.EventSet, dumpIds, x => assets.LoadEventSet(x)));
Flush();
}
if (types.Contains(AssetType.Script))
{
foreach (var id in DumpUtil.All(AssetType.Script, dumpIds))
{
IList <IEvent> asset = assets.LoadScript(id);
if (asset == null)
{
continue;
}
tw = Writer($"scripts/script{id.Id}.json");
s.Serialize(tw, asset.Select(x => x.ToString()).ToArray());
}
Flush();
}
if (types.Contains(AssetType.Spell))
{
tw = Writer("spells.json");
s.Serialize(tw, DumpUtil.AllAssets(AssetType.Spell, dumpIds, x => assets.LoadSpell(x)));
Flush();
}
if (types.Contains(AssetType.MonsterGroup))
{
tw = Writer("monster_groups.json");
s.Serialize(tw, DumpUtil.AllAssets(AssetType.MonsterGroup, dumpIds, x => assets.LoadMonsterGroup(x)));
Flush();
}
if (types.Contains(AssetType.Palette))
{
foreach (var id in DumpUtil.All(AssetType.Palette, dumpIds))
{
tw = Writer($"palettes/palette{id.Id}_{id}.json");
var palette = assets.LoadPalette(id);
s.Serialize(tw, palette);
}
Flush();
}
}
/// <summary>
/// Gibt das Tileset zurück in welchem
/// das Tile ist
/// </summary>
/// <param name="number"></param>
/// <returns></returns>
public TilesetData GetTileset(int number)
{
TilesetData ret=new TilesetData();
foreach(TilesetData i in Tilesets)
{
if(number>=i.firstgid)
{
ret=i;
}
}
return ret;
}
void Open(string filename, bool loadTilesets)
{
//Datei öffnen
Tilesets=new List<TilesetData>();
Layers=new List<LayerData>();
ObjectLayers=new List<Objectgroup>();
Properties=new List<Property>();
//XMLdata öffnen
FileData=new XmlData(filename);
#region MapsInfo ermitteln
XmlNodeList xnl=FileData.Document.SelectNodes("/map");
MapVersion=xnl[0].Attributes["version"].Value;
Orientation=xnl[0].Attributes["orientation"].Value;
Width=Convert.ToInt32(xnl[0].Attributes["width"].Value);
Height=Convert.ToInt32(xnl[0].Attributes["height"].Value);
TileWidth=Convert.ToInt32(xnl[0].Attributes["tilewidth"].Value);
TileHeight=Convert.ToInt32(xnl[0].Attributes["tileheight"].Value);
#endregion
#region Properties auslesen
xnl=FileData.Document.SelectNodes("/map/properties");
foreach(XmlNode j in xnl)
{
XmlNodeList subnodes=j.SelectNodes("child::property");
foreach(XmlNode pNode in subnodes)
{
string name=pNode.Attributes[0].Name;
string value=pNode.Attributes[0].Value;
Properties.Add(new Property(pNode));
}
}
#endregion
#region Tilesets ermitteln
xnl=FileData.Document.SelectNodes("/map/tileset");
foreach(XmlNode j in xnl)
{
//Tilesets
TilesetData ts=new TilesetData();
ts.imgsource=j.SelectNodes("child::image")[0].Attributes[0].Value; //Image Source für den Layer
string imgsourceComplete=FileSystem.GetPath(filename)+ts.imgsource;
//Tiles laden, wenn vorhanden
XmlNodeList nodelist=j.SelectNodes("child::tile");
foreach(XmlNode tileXml in nodelist)
{
Tile tile=new Tile();
tile.ID=tileXml.Attributes["id"].Value.ToString();
xnl=tileXml.SelectNodes("child::properties");
foreach(XmlNode jProp in xnl)
{
XmlNodeList subnodes=jProp.SelectNodes("child::property");
foreach(XmlNode pNode in subnodes)
{
tile.Properties.Add(new Property(pNode));
}
}
ts.Tiles.Add(tile);
}
//Tilebildl laden
if(loadTilesets)
{
try
{
ts.img=pooledLoader.FromFile(imgsourceComplete);
}
catch(FileNotFoundException ex)
{
throw new TilesetNotExistsException(ex.Message);
}
}
//Attrribute
ts.name=j.Attributes["name"].Value;
ts.firstgid=Convert.ToInt32(j.Attributes["firstgid"].Value);
ts.tilewidth=Convert.ToInt32(j.Attributes["tilewidth"].Value);
ts.tileheight=Convert.ToInt32(j.Attributes["tileheight"].Value);
Tilesets.Add(ts);
}
#endregion
#region Layers ermitteln
xnl=FileData.Document.SelectNodes("/map/layer");
foreach(XmlNode j in xnl) //pro layer
{
//Layer
LayerData lr=new LayerData();
//Attribute
lr.name=j.Attributes["name"].Value;
lr.width=Convert.ToInt32(j.Attributes["width"].Value);
lr.height=Convert.ToInt32(j.Attributes["height"].Value);
//Layerdaten
// Attribute werden als "<data encoding="base64" compression="gzip">" angenommen
string encoding=j["data"].Attributes["encoding"].Value;
string compression="uncompressed";
if(j["data"].Attributes["compression"]!=null)
{
compression=j["data"].Attributes["compression"].Value;
}
if(encoding!="base64")
{
throw (new NotImplementedException("Weitere Codierungsarten sind noch nicht implementiert!"));
}
if(compression!="uncompressed"&&compression!="gzip")
{
throw (new NotSupportedCompressionException("Weitere Kompressionsverfahren sind noch nicht implementiert!"));
}
//Base64 Encodierung
string layerdataBase64Compressed=j.SelectNodes("child::data")[0].InnerText;
layerdataBase64Compressed=layerdataBase64Compressed.TrimStart('\n');
layerdataBase64Compressed=layerdataBase64Compressed.Trim();
byte[] layerdataCompressed=CSCL.Crypto.Encoding.Base64.Decode(layerdataBase64Compressed);
//Gzip Decodierung (wenn nötig)
byte[] layerdataDecompressed;
if(compression=="uncompressed")
{
layerdataDecompressed=layerdataCompressed;
}
else
{
layerdataDecompressed=gzip.Decompress(layerdataCompressed);
}
//Interpretieren der Codierten Daten
lr.data=new int[lr.width, lr.height];
//int[,] zelle=new int[4, 3];
BinaryReader br=new BinaryReader(new MemoryStream(layerdataDecompressed));
for(int y=0;y<lr.height;y++)
{
for(int x=0;x<lr.width;x++)
{
lr.data[x, y]=br.ReadInt32();
}
}
Layers.Add(lr);
}
#endregion
#region Objektlayer ermitteln
xnl=FileData.Document.SelectNodes("/map/objectgroup");
foreach(XmlNode j in xnl) //pro layer
{
ObjectLayers.Add(new Objectgroup(j));
}
#endregion
}
