public StructureViewModel(JsdStruct aStructure)
 {
     this.FRemoveTileCommand.IsCanExecuteProperty = false;
     this.FCopyTileCommand.IsCanExecuteProperty   = false;
     this.PropertyChanged += StructureViewModel_PropertyChanged;
     this.Load(aStructure);
 }
        public void Execute(object parameter)
        {
            JsdFileViewModel _jsdViewModel = (JsdFileViewModel)parameter;
            JsdStruct        _struct       = _jsdViewModel.SelectedStruct.Structure.Clone();

            _jsdViewModel.AddJsdStructure(_struct);
        }
        public void Execute(object parameter)
        {
            JsdFileViewModel _jsdViewModel = (JsdFileViewModel)parameter;
            JsdStruct        _struct       = new JsdStruct(_jsdViewModel.IsHighDefenition);

            _jsdViewModel.AddJsdStructure(_struct);
        }
        public void AddJsdStructure(JsdStruct aJsdStruct)
        {
            this.JsdFile.AddStruct(aJsdStruct);
            StructureViewModel _structureViewModel = new StructureViewModel(aJsdStruct);

            this.Structs.Add(_structureViewModel);
            this.SelectedStruct = _structureViewModel;
        }
        public void Execute(object parameter)
        {
            JsdFileViewModel   _viewModel      = (JsdFileViewModel)parameter;
            StructureViewModel _selectedStruct = _viewModel.SelectedStruct;
            JsdStruct          _rotatedStruct  = _selectedStruct.Structure.Clone();

            _rotatedStruct.Rotate(false);
            _viewModel.AddJsdStructure(_rotatedStruct);
        }
        public void BuildMap()
        {
            int _mapSize = this.ViewModel.Map.WORLD_SIZE;

            for (int i = 0; i < _mapSize; i++)
            {
                for (int j = 0; j < _mapSize; j++)
                {
                    for (int k = 0; k < this.ViewModel.DrewLayers.Length; k++)
                    {
                        if (k == 1 || k == 3 || !this.ViewModel.DrewLayers[k])
                        {
                            continue;
                        }

                        MapElement element = this.ViewModel.Map.Elementes[_mapSize * j + i];

                        foreach (LevelNode.TileIndex tileIndex in element.pLevelNodes[k].tileIndexes)
                        {
                            int     _subIndex = tileIndex.usTypeSubIndex - 1;
                            JsdFile _jsdFile  = this.ViewModel.Map.MapTileSet[tileIndex.ubType].Jsd;

                            if (_jsdFile == null)
                            {
                                continue;
                            }

                            JsdStruct _jsdStruct = _jsdFile.Structs.
                                                   SingleOrDefault(x => x.StructureNumber == _subIndex);

                            if (_jsdStruct != null)
                            {
                                for (int l = 0; l < _jsdStruct.Tiles.Length; l++)
                                {
                                    JsdTile _tile = _jsdStruct.Tiles[l].Clone();
                                    if (k > 3)
                                    {
                                        _tile.Flags |= JsdTile.JsdTileFlags.TILE_ON_ROOF;
                                    }
                                    _tile.XPosRelToBase += (sbyte)(i - _mapSize / 2);
                                    _tile.YPosRelToBase += (sbyte)(j - _mapSize / 2);
                                    GeometryModel3D _tileGeometry = this.AddTile(_tile);
                                    this.FLayers[k].Add(_tileGeometry);
                                }
                            }

                            if (this.FPh.Progress < 0)
                            {
                                return;
                            }
                        }
                    }
                }
                this.FPh.Progress = i * 100 / _mapSize;
            }
        }
        public void Load(JsdStruct aStructure)
        {
            if (aStructure != null)
            {
                this.FStructure = aStructure;

                if (aStructure.Tiles != null)
                {
                    var _tiles = aStructure.Tiles.Select(x => new TileViewModel(x));
                    this.FTiles = new ObservableCollection <TileViewModel>(_tiles);
                    this.FTiles.CollectionChanged += Tiles_CollectionChanged;
                }

                this.FIsHighDefenition = aStructure.IsHighDefenition;
            }
            else
            {
                this.FStructure = new JsdStruct(false);
            }
        }