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 JsdFileViewModel(JsdFile aJsdFile, string aFileName)
{
this.FJsdFile = aJsdFile;
this.FileName = aFileName;
this.FStructs = new ObservableCollection <StructureViewModel>(
aJsdFile.Structs.Select(x => new StructureViewModel(x)));
this.FStructs.CollectionChanged += FStructs_CollectionChanged;
this.FAuxData = new ObservableCollection <AuxDataViewModel>(
aJsdFile.Auxilarity.Select(x => new AuxDataViewModel(x, aJsdFile.GetAuxTileLocData(x))));
this.FAuxData.CollectionChanged += FAuxData_CollectionChanged;
this.PropertyChanged += JsdFileViewModel_PropertyChanged;
}
private void FLoadSlfWorker_DoWork(object sender, DoWorkEventArgs e)
{
this.IsBusy = true;
try
{
string _slfFileName = (string)e.Argument;
SlfFile _slfFile = new SlfFile(_slfFileName);
_slfFile.LoadRecords();
var _jsdRecords = _slfFile.Records.Where(x => x.FileNameExtention.ToLower() == ".jsd");
int _recNum = _jsdRecords.Count();
foreach (SlfFile.Record _record in _jsdRecords)
{
JsdFileViewModel _jsdFileViewModel = null;
MemoryStream _ms = new MemoryStream(_record.Data);
JsdFile _jsdFile = JsdFile.Load(_ms);
_ms.Close();
_jsdFileViewModel = new JsdFileViewModel(_jsdFile, _record.FileName);
SlfFile.Record _stiRecord = _slfFile.Records
.Where(x => x.FileName.ToLower() == _record.FileName.ToLower().Replace(".jsd", ".sti"))
.SingleOrDefault();
if (_stiRecord != null)
{
_ms = new MemoryStream(_stiRecord.Data);
IStci _stci = StciLoader.LoadStci(_ms);
if (_stci.IsIndexed)
{
_jsdFileViewModel.StciFile = (StciIndexed)_stci;
}
}
this.JsdFilesCount++;
this.FLoadSlfWorker.ReportProgress(100 * this.JsdFilesCount / _recNum, _jsdFileViewModel);
}
}
finally
{
this.IsBusy = false;
}
}
private void FConvertBackGroundWorker_DoWork(object sender, DoWorkEventArgs e)
{
this.IsBusy = true;
try
{
string[] _files = (string[])e.Argument;
int _filesCount = 0;
foreach (string _fileName in _files)
{
JsdFile.ConvertJsdFileToHighDefinition(_fileName);
_filesCount++;
this.FConvertBackGroundWorker.ReportProgress(100 * _filesCount / _files.Length);
}
}
finally
{
this.IsBusy = false;
}
}
public async void Execute(object parameter)
{
TestViewModel _viewModel = (TestViewModel)parameter;
DirectoryInfo _dir = new DirectoryInfo(_viewModel.FolderName);
this.IsCanExecute = false;
this.IsCanExecute = await Task.Run <bool>(() =>
{
try
{
_viewModel.StatusString = String.Empty;
_viewModel.ResultString = String.Empty;
_viewModel.StatusString = String.Empty;
FileInfo[] _files = _dir.GetFiles("*.JSD", SearchOption.AllDirectories);
string _currentDir = String.Empty;
int _i = 0;
foreach (FileInfo _file in _files)
{
JsdFile.ConvertJsdFileToHighDefinition(_file.FullName);
if (_currentDir != _file.DirectoryName)
{
_currentDir = _file.DirectoryName;
_viewModel.StatusString = String.Format("{0} processing ...", _currentDir);
_viewModel.ResultString = String.Format("{0} folders processed ...", ++_i);
}
}
_viewModel.StatusString = "Done";
}
catch (Exception exc)
{
_viewModel.ErrorString = Common.GetErrorString(exc);
}
return(true);
});
}
private void btnConvert_Click(object sender, RoutedEventArgs e)
{
MessageBoxResult _result = MessageBox.Show(
"Files will be overrwritten.", "Convertation JSD to JSD-HD", MessageBoxButton.OKCancel);
if (_result != MessageBoxResult.OK)
{
return;
}
ProgressHolder _ph = new ProgressHolder();
_ph.IsCancelable = true;
ProgressWindow.Run(_ph);
int _filesCount = 0;
try
{
foreach (string _fileName in this.FFileNames)
{
if (_ph.Progress < 0)
{
break;
}
JsdFile.ConvertJsdFileToHighDefinition(_fileName);
_filesCount++;
_ph.Progress = 100 * _filesCount / this.FFileNames.Length;
}
}
finally
{
_ph.Progress = -1;
}
}
public async void Execute(object parameter)
{
TestViewModel _viewModel = (TestViewModel)parameter;
this.IsCanExecute = false;
this.IsCanExecute = await Task.Run <bool>(() =>
{
try
{
_viewModel.StatusString = String.Empty;
_viewModel.ResultString = String.Empty;
_viewModel.ResultString = JsdFile.ReloadJsdFile(_viewModel.FileName);
_viewModel.StatusString = "Done";
}
catch (Exception exc)
{
_viewModel.ErrorString = Common.GetErrorString(exc);
}
return(true);
});
}
public async void Execute(object parameter)
{
TestViewModel _viewModel = (TestViewModel)parameter;
this.IsCanExecute = false;
this.IsCanExecute = await Task.Run <bool>(() =>
{
try
{
_viewModel.StatusString = String.Empty;
_viewModel.ResultString = String.Empty;
using (FileStream _fs = new FileStream(_viewModel.FileName, FileMode.Open))
{
JsdFile _jsd = JsdFile.Load(_fs);
_viewModel.ResultString += _jsd.ToString();
foreach (JsdStruct _struct in _jsd.Structs)
{
_struct.Rotate(true);
}
_viewModel.ResultString += "===================================================";
_viewModel.ResultString += _jsd.ToString();
}
_viewModel.StatusString = "Done";
}
catch (Exception exc)
{
_viewModel.ErrorString = Common.GetErrorString(exc);
}
return(true);
});
}
public JsdFileViewModel LoadJsdFile(string aFile)
{
FileStream _fs = new FileStream(aFile, FileMode.Open);
JsdFile _jsdFile = JsdFile.Load(_fs);
_fs.Close();
string _fileName = String.Empty;
if (this.FolderName != String.Empty)
{
_fileName = aFile.Replace(this.FolderName, String.Empty);
}
else
{
_fileName = Path.GetFileName(aFile);
}
JsdFileViewModel _jsdFileViewModel = new JsdFileViewModel(_jsdFile, _fileName);
_jsdFileViewModel.FullFileName = aFile;
string _stiFileName = Path.ChangeExtension(aFile, ".sti");
if (File.Exists(_stiFileName))
{
_fs = new FileStream(_stiFileName, FileMode.Open);
IStci _stci = StciLoader.LoadStci(_fs);
_fs.Close();
if (_stci.IsIndexed)
{
_jsdFileViewModel.StciFile = (StciIndexed)_stci;
}
}
return(_jsdFileViewModel);
}
public void LoadMapTileSet(Map aMap)
{
for (int k = 0; k < TileSet.NumOfTileTypes; k++)
{
string _fileName = TileSet.TileSets[aMap.TilesetID].TileSurfaceFilenames[k];
int _tilesetId = aMap.TilesetID;
if (_fileName == String.Empty)
{
_fileName = TileSet.TileSets[0].TileSurfaceFilenames[k];
_tilesetId = 0;
}
_fileName = Path.Combine(_tilesetId.ToString(), _fileName);
string _path = Path.Combine(this.FTilesetFolder, _fileName);
StciIndexed _sti = null;
if (File.Exists(_path))
{
//using(FileStream input = new FileStream(_path, FileMode.Open, FileAccess.Read))
_sti = (StciIndexed)StciLoader.LoadStci(_path);
}
else
{
if (File.Exists(this.FTilesetFileName))
{
SlfFile.Record _record = this.TilesetSlfFile.Records
.SingleOrDefault(x => x.State == 0 && x.FileName.ToUpperInvariant() == _fileName.ToUpperInvariant());
if (_record != null)
{
using (MemoryStream input = new MemoryStream(_record.Data))
_sti = (StciIndexed)StciLoader.LoadStci(input, _fileName);
}
else
{
throw new FileNotFoundException(
String.Format("Record {0} is not found in file {1}.", _fileName, this.FTilesetFileName));
}
}
else
{
throw new FileNotFoundException(
String.Format("Files {0}, {1} are not found.", _path, this.FTilesetFileName));
}
}
JsdFile _jsd = null;
_path = Path.ChangeExtension(_path, ".jsd");
if (File.Exists(_path))
{
using (FileStream input = new FileStream(_path, FileMode.Open, FileAccess.Read))
{
_jsd = JsdFile.Load(input);
}
}
else
{
if (File.Exists(this.FTilesetFileName))
{
_fileName = Path.ChangeExtension(_fileName, "jsd");
SlfFile.Record _record = this.TilesetSlfFile.Records
.SingleOrDefault(x => x.FileName.ToUpperInvariant() == _fileName.ToUpperInvariant());
if (_record != null)
{
using (MemoryStream input = new MemoryStream(_record.Data))
_jsd = JsdFile.Load(input);
}
//else
//{
// throw new FileNotFoundException(
// String.Format("Record {0} is not found in file {1}.", _fileName, this.FTilesetFileName));
//}
}
//else
//{
// throw new FileNotFoundException(
// String.Format("Files {0}, {1} are not found.", _path, this.FTilesetFileName));
//}
}
aMap.MapTileSet[k] = new Map.TileObject(_sti, _jsd);
}
}
