Example #1
0
        public void BindTilePoolManager(ITilePoolManager manager)
        {
            if (_poolManager != null)
            {
                _poolManager.PoolAdded    -= TilePoolAdded;
                _poolManager.PoolRemoved  -= TilePoolRemoved;
                _poolManager.PoolModified -= TilePoolModified;
            }

            _poolManager = manager;
            if (_poolManager != null)
            {
                _poolManager.PoolAdded    += TilePoolAdded;
                _poolManager.PoolRemoved  += TilePoolRemoved;
                _poolManager.PoolModified += TilePoolModified;

                InitializePoolPresenters();
            }
            else
            {
                ClearPoolPresenters();
            }

            OnSyncTilePoolManager(EventArgs.Empty);
        }
Example #2
0
        private void WriteTileSets(ContentWriter output, LevelContent content)
        {
            ITilePoolManager mgr = content.Level.Project.TilePoolManager;

            output.Write(mgr.Pools.Count);
            foreach (TilePool pool in mgr.Pools)
            {
                WriteTileSet(output, content, pool);
            }
        }
Example #3
0
 private void BindTilePoolManager(ITilePoolManager manager)
 {
     if (manager != null)
     {
         _layerControl.TextureCache.SourcePool = manager.TexturePool;
     }
     else
     {
         _layerControl.TextureCache.SourcePool = null;
     }
 }
        private void ParseTileBlockString(string blockString)
        {
            string[] tokens = blockString.Split(new char[] { ' ' });

            ITilePoolManager manager = Level.Project.TilePoolManager;

            for (int i = 0; i < tokens.Length; i += 3)
            {
                if (tokens.Length - i < 3)
                {
                    break;
                }

                int x     = int.Parse(tokens[i + 0]);
                int y     = int.Parse(tokens[i + 1]);
                int count = int.Parse(tokens[i + 2]);

                if (tokens.Length - i < 3 + count)
                {
                    break;
                }

                for (int j = 0; j < count; j++)
                {
                    int tileId = int.Parse(tokens[i + 3 + j]);

                    if (Level.TileIndex.ContainsKey(tileId))
                    {
                        Guid tileUid = Level.TileIndex[tileId];

                        TilePool pool = manager.PoolFromItemKey(tileUid);
                        Tile     tile = pool.GetTile(tileUid);

                        AddTile(x, y, tile);
                    }
                }

                i += count;
            }
        }
        private void Bind(ITilePoolManager manager)
        {
            if (_tilePoolManager == manager)
            {
                return;
            }

            if (_tilePoolManager != null)
            {
                _tilePoolManager.PoolAdded    -= _tilePoolEventBindings[EventBindings.TilePoolAdded];
                _tilePoolManager.PoolRemoved  -= _tilePoolEventBindings[EventBindings.TilePoolRemoved];
                _tilePoolManager.PoolModified -= _tilePoolEventBindings[EventBindings.TilePoolModified];
            }

            _tilePoolManager = manager;

            if (_tilePoolManager != null)
            {
                _tilePoolManager.PoolAdded    += _tilePoolEventBindings[EventBindings.TilePoolAdded];
                _tilePoolManager.PoolRemoved  += _tilePoolEventBindings[EventBindings.TilePoolRemoved];
                _tilePoolManager.PoolModified += _tilePoolEventBindings[EventBindings.TilePoolModified];
            }
        }
Example #6
0
        private TilePool LoadFile(ITilePoolManager manager)
        {
            if (_fileStream == null) {
                return null;
            }

            if (_fileStream.Position != 0) {
                _fileStream.Position = 0;
            }

            _localManager.Reset();

            TextureResource resource = TextureResourceBitmapExt.CreateTextureResource(_fileStream);
            TilePool.TileImportOptions options = new TilePool.TileImportOptions()
            {
                TileHeight = (int)_numTileHeight.Value,
                TileWidth = (int)_numTileWidth.Value,
                SpaceX = (int)_numXSpacing.Value,
                SpaceY = (int)_numYSpacing.Value,
                MarginX = (int)_numXMargin.Value,
                MarginY = (int)_numYMargin.Value,
                ImportPolicty = TileImportPolicy.SetUnique,
            };

            _previewPool = _localManager.ImportPool(_textName.Text, resource, options);
            _originalResource = _previewPool.TileSource.Crop(_previewPool.TileSource.Bounds);

            if (_useTransColor)
                SetTransparentColor();

            // Update preview window

            if (_previewLayer != null)
                _previewLayer.Dispose();

            Model.TileSetLayer layer = new Model.TileSetLayer(_previewPool.Name, _previewPool);
            _previewLayer = new TileSetLayerPresenter(layer) {
                LevelGeometry = _layerControl.LevelGeometry,
            };

            _rootLayer.Layers.Clear();
            _rootLayer.Layers.Add(_previewLayer);

            // Update stats

            _countTilesHigh.Text = ((_height + (int)_numYSpacing.Value) / ((int)_numTileHeight.Value + (int)_numYSpacing.Value + (int)_numYMargin.Value)).ToString();
            _countTilesWide.Text = ((_width + (int)_numXSpacing.Value) / ((int)_numTileWidth.Value + (int)_numXSpacing.Value + (int)_numXMargin.Value)).ToString();
            _countUniqueTiles.Text = _previewPool.Count.ToString();

            return _previewPool;
        }
        public void BindTilePoolManager(ITilePoolManager manager)
        {
            if (_poolManager != null) {
                _poolManager.Pools.ResourceAdded -= TilePoolAdded;
                _poolManager.Pools.ResourceRemoved -= TilePoolRemoved;
                //_poolManager.Pools.ResourceRemapped -= TilePoolRemapped;
                //_poolManager.Pools.CollectionChanged -= TilePoolManagerChanged;
            }

            _poolManager = manager;
            if (_poolManager != null) {
                _poolManager.Pools.ResourceAdded += TilePoolAdded;
                _poolManager.Pools.ResourceRemoved += TilePoolRemoved;
                //_poolManager.Pools.ResourceRemapped += TilePoolRemapped;
                //_poolManager.Pools.CollectionChanged += TilePoolManagerChanged;

                InitializePoolPresenters();
            }
            else {
                ClearPoolPresenters();
            }

            OnSyncTilePoolManager(EventArgs.Empty);
        }
Example #8
0
 private void BindTilePoolManager(ITilePoolManager manager)
 {
     if (manager != null) {
         _layerControl.TextureCache.SourcePool = manager.TexturePool;
     }
     else {
         _layerControl.TextureCache.SourcePool = null;
     }
 }
        public void BindTilePoolManager(ITilePoolManager manager)
        {
            if (_poolManager != null) {
                _poolManager.PoolAdded -= TilePoolAdded;
                _poolManager.PoolRemoved -= TilePoolRemoved;
                _poolManager.PoolModified -= TilePoolModified;
            }

            _poolManager = manager;
            if (_poolManager != null) {
                _poolManager.PoolAdded += TilePoolAdded;
                _poolManager.PoolRemoved += TilePoolRemoved;
                _poolManager.PoolModified += TilePoolModified;

                InitializePoolPresenters();
            }
            else {
                ClearPoolPresenters();
            }

            OnSyncTilePoolManager(EventArgs.Empty);
        }
        private void BindTilePoolManager(ITilePoolManager manager)
        {
            if (_tilePoolManager == manager)
                return;

            if (_tilePoolManager != null) {
                _tilePoolManager.Pools.ResourceAdded -= _tilePoolEventBindings[EventBindings.TilePoolAdded];
                _tilePoolManager.Pools.ResourceRemoved -= _tilePoolEventBindings[EventBindings.TilePoolRemoved];
                _tilePoolManager.Pools.ResourceModified -= _tilePoolEventBindings[EventBindings.TilePoolModified];
            }

            _tilePoolManager = manager;

            if (_tilePoolManager != null) {
                _tilePoolManager.Pools.ResourceAdded += _tilePoolEventBindings[EventBindings.TilePoolAdded];
                _tilePoolManager.Pools.ResourceRemoved += _tilePoolEventBindings[EventBindings.TilePoolRemoved];
                _tilePoolManager.Pools.ResourceModified += _tilePoolEventBindings[EventBindings.TilePoolModified];
            }
        }