/// <summary>
        /// Converts the domain model into an entity.
        /// </summary>
        /// <returns>The entity.</returns>
        /// <param name="worldTile">World Tile.</param>
        internal static WorldTileEntity ToEntity(this WorldTile worldTile)
        {
            WorldTileEntity worldEntity = new WorldTileEntity
            {
                BiomeId    = worldTile.BiomeId,
                ProvinceId = worldTile.ProvinceId
            };

            return(worldEntity);
        }
        /// <summary>
        /// Converts the entity into a domain model.
        /// </summary>
        /// <returns>The domain model.</returns>
        /// <param name="worldTileEntity">World Tile entity.</param>
        internal static WorldTile ToDomainModel(this WorldTileEntity worldTileEntity)
        {
            WorldTile worldTile = new WorldTile
            {
                BiomeId    = worldTileEntity.BiomeId,
                ProvinceId = worldTileEntity.ProvinceId
            };

            return(worldTile);
        }
Example #3
0
        /// <summary>
        /// Converts the domain model into an entity.
        /// </summary>
        /// <returns>The entity.</returns>
        /// <param name="worldTile">World geographic layer.</param>
        internal static WorldTileEntity ToEntity(this WorldTile worldTile)
        {
            WorldTileEntity worldTileEntity = new WorldTileEntity
            {
                SpriteSheetFrame = worldTile.SpriteSheetFrame,
                ObjectId         = worldTile.ObjectId,
                TerrainId        = worldTile.TerrainId
            };

            return(worldTileEntity);
        }
Example #4
0
        /// <summary>
        /// Converts the entity into a domain model.
        /// </summary>
        /// <returns>The domain model.</returns>
        /// <param name="worldTileEntity">World geographic layer entity.</param>
        internal static WorldTile ToDomainModel(this WorldTileEntity worldTileEntity)
        {
            WorldTile worldTile = new WorldTile
            {
                SpriteSheetFrame = worldTileEntity.SpriteSheetFrame,
                ObjectId         = worldTileEntity.ObjectId,
                TerrainId        = worldTileEntity.TerrainId
            };

            return(worldTile);
        }
        /// <summary>
        /// Converts the domain models into entities.
        /// </summary>
        /// <returns>The entities.</returns>
        /// <param name="worldTiles">World Tiles.</param>
        internal static WorldTileEntity[,] ToEntities(this WorldTile[,] worldTiles)
        {
            int w = worldTiles.GetLength(0);
            int h = worldTiles.GetLength(1);

            WorldTileEntity[,] worldTileEntities = new WorldTileEntity[w, h];

            Parallel.For(0, h, y => Parallel.For(0, w, x => worldTileEntities[x, y] = worldTiles[x, y].ToEntity()));

            return(worldTileEntities);
        }
Example #6
0
        /// <summary>
        /// Converts the domain models into entities.
        /// </summary>
        /// <returns>The entities.</returns>
        /// <param name="worldTiles">World geographic layer.</param>
        internal static WorldTileEntity[,] ToEntities(this WorldTile[,] worldTiles)
        {
            int cols = worldTiles.GetLength(0);
            int rows = worldTiles.GetLength(1);

            WorldTileEntity[,] worldTileEntities = new WorldTileEntity[cols, rows];

            for (int y = 0; y < rows; y++)
            {
                for (int x = 0; x < cols; x++)
                {
                    worldTileEntities[x, y] = worldTiles[x, y].ToEntity();
                }
            }

            return(worldTileEntities);
        }
Example #7
0
        WorldTileEntity[,] LoadWorldTiles(string worldId)
        {
            ConcurrentDictionary <int, string> provinceColourIds = new ConcurrentDictionary <int, string>();
            ConcurrentDictionary <int, string> biomeColourIds    = new ConcurrentDictionary <int, string>();

            IBiomeRepository    biomeRepository    = new BiomeRepository(Path.Combine(worldsDirectory, worldId, "biomes.xml"));
            IProvinceRepository provinceRepository = new ProvinceRepository(Path.Combine(worldsDirectory, worldId, "provinces.xml"));

            Parallel.ForEach(biomeRepository.GetAll(), b => biomeColourIds.AddOrUpdate(ColorTranslator.FromHtml(b.ColourHexadecimal).ToArgb(), b.Id));
            Parallel.ForEach(provinceRepository.GetAll(), r => provinceColourIds.AddOrUpdate(ColorTranslator.FromHtml(r.ColourHexadecimal).ToArgb(), r.Id));

            FastBitmap biomeBitmap    = new FastBitmap(Path.Combine(worldsDirectory, worldId, "biomes_map.png"));
            FastBitmap provinceBitmap = new FastBitmap(Path.Combine(worldsDirectory, worldId, "map.png"));

            Point worldSize = new Point(Math.Max(biomeBitmap.Width, provinceBitmap.Width),
                                        Math.Max(biomeBitmap.Height, provinceBitmap.Height));

            WorldTileEntity[,] tiles = new WorldTileEntity[provinceBitmap.Width, provinceBitmap.Height];

            Parallel.For(0, worldSize.Y, y => Parallel.For(0, worldSize.X, x => tiles[x, y] = new WorldTileEntity()));

            biomeBitmap.LockBits();
            provinceBitmap.LockBits();

            Parallel.For(0, biomeBitmap.Height, y => Parallel.For(0, biomeBitmap.Width, x =>
            {
                int argb            = biomeBitmap.GetPixel(x, y).ToArgb();
                tiles[x, y].BiomeId = biomeColourIds[argb];
            }));

            Parallel.For(0, provinceBitmap.Height, y => Parallel.For(0, provinceBitmap.Width, x =>
            {
                int argb = provinceBitmap.GetPixel(x, y).ToArgb();
                tiles[x, y].ProvinceId = provinceColourIds[argb];
            }));

            biomeBitmap.Dispose();
            provinceBitmap.Dispose();

            return(tiles);
        }
        WorldTileEntity ProcessTmxLayerTile(TmxLayerTile tmxLayerTile, TmxTileset tmxTileset)
        {
            WorldTileEntity tile = new WorldTileEntity
            {
                SpriteSheetFrame = Math.Max(-1, tmxLayerTile.Gid - tmxTileset.FirstGid)
            };

            if (tile.SpriteSheetFrame < 0)
            {
                return(tile);
            }

            TmxTilesetTile tmxTilesetTile = tmxTileset.Tiles.FirstOrDefault(x => x.Id == tile.SpriteSheetFrame);

            if (tmxTilesetTile == null)
            {
                return(tile);
            }

            string objectId  = string.Empty;
            string terrainId = string.Empty;

            if (tmxTilesetTile.Properties.ContainsKey("ObjectId"))
            {
                tile.ObjectId = tmxTilesetTile.Properties["ObjectId"];
            }

            if (tmxTilesetTile.Properties.ContainsKey("TerrainId"))
            {
                tile.TerrainId = tmxTilesetTile.Properties["TerrainId"];
            }

            tile.ObjectId  = string.IsNullOrWhiteSpace(objectId) ? tile.ObjectId : objectId;
            tile.TerrainId = string.IsNullOrWhiteSpace(terrainId) ? tile.TerrainId : terrainId;

            return(tile);
        }