public Tile GetTile(FloorTileData t)
{
SetMinimapTile(Color.White);
var initalizer = new FloorInitializer();
var res = new FloorTile(initalizer);
sidesCreator.SetupSidesAsync(initalizer, currentGridPosition, res);
res.Renderer = builder.Factories.RenderersSource.GetTileRenderer(res);
this.initializer = initalizer;
return(res);
}
private Bitmap GetFloorTile(FileInfo fileFloor, FloorTileData floorTileData, string animation, string frame)
{
if (floorTileData != null && floorTileData.HasTileFile)
{
if (fileFloor.Exists)
{
return(new Bitmap(Image.FromFile(fileFloor.FullName)));
}
else
{
return(MissingAnimationFloorCreator.CreateTileWithTextLines(_missingFloorTileType, animation, frame));
}
}
else
{
return(null);
}
}
private Bitmap GetFloorTile(FileInfo fileFloor, FloorTileData floorTileData, string replacementName, string tileName)
{
if (floorTileData != null && floorTileData.HasTileFile)
{
if (fileFloor.Exists)
{
return(new Bitmap(Image.FromFile(fileFloor.FullName)));
}
else
{
return(MissingReplacementFloorCreator.CreateTileWithTextLines(_missingFloorTileType, replacementName, tileName));
}
}
else
{
return(null);
}
}
public override void CompileOne(string[] splitLine)
{
if (splitLine.Length < _lineLength)
{
throw new Exception(string.Format("Animation line '{0}' has too few elements.", string.Join(',', splitLine)));
}
var animation = splitLine[1];
var frame = splitLine[2];
var originalTileNumber = int.Parse(splitLine[3]);
int subIndex = 0;
int widthInTiles = int.Parse(splitLine[4]);
int heightInTiles = int.Parse(splitLine[5]);
int mainTileAlignmentInt = int.Parse(splitLine[6]);
if (!Enum.IsDefined(typeof(MainTileAlignment), mainTileAlignmentInt))
{
throw new Exception(string.Format("MainTileAlignment '{0}' is invalid. Should be 0 or 1.", mainTileAlignmentInt));
}
MainTileAlignment mainTileAlignment = (MainTileAlignment)mainTileAlignmentInt;
TileData originalTileData = GetTileFile(originalTileNumber, subIndex);
Point? originalFilePointInTiles = originalTileData != null ? originalTileData.PointInTiles : null;
Size? originalFileBitmapSizeInTiles = originalTileData != null ? originalTileData.BitmapSizeInTiles : null;
bool flipHorizontal = originalTileData != null ? originalTileData.FlipHorizontal : false;
bool flipVertical = originalTileData != null ? originalTileData.FlipVertical : false;
var dirPath = Path.Combine(BaseDirectory.FullName, animation.ToFileName());
var fileName = animation.ToFileName() + "_" + frame.ToFileName() + Program.ImageFileExtension;
var fileName2 = frame.ToFileName() + Program.ImageFileExtension;
var fileNameFloor = animation.ToFileName() + "_" + frame.ToFileName() + _floorSuffix + Program.ImageFileExtension;
var fileNameFloor2 = frame.ToFileName() + _floorSuffix + Program.ImageFileExtension;
var relativePath = Path.Combine(_subDirName, animation.ToFileName(), fileName);
var relativePath2 = Path.Combine(_subDirName, animation.ToFileName(), fileName2);
var filePath = Path.Combine(dirPath, fileName);
FileInfo file = new FileInfo(filePath);
var filePath2 = Path.Combine(dirPath, fileName2);
FileInfo file2 = new FileInfo(filePath2);
var filePathFloor = Path.Combine(dirPath, fileNameFloor);
FileInfo fileFloor = new FileInfo(filePathFloor);
var filePathFloor2 = Path.Combine(dirPath, fileNameFloor2);
FileInfo fileFloor2 = new FileInfo(filePathFloor2);
FileInfo template = null;
FileInfo template2 = null;
string templateRelativePath = null;
string templateRelativePath2 = null;
if (originalTileData != null)
{
var originalFileNameWithoutExtension = Path.GetFileNameWithoutExtension(originalTileData.File.Name).ToFileName();
var templateDir = Path.Combine(BaseDirectory.FullName, originalFileNameWithoutExtension);
var templateName = originalFileNameWithoutExtension + "_" + frame.ToFileName() + Program.ImageFileExtension;
var templateName2 = frame.ToFileName() + Program.ImageFileExtension;
templateRelativePath = Path.Combine(_subDirName, originalFileNameWithoutExtension, templateName);
templateRelativePath2 = Path.Combine(_subDirName, originalFileNameWithoutExtension, templateName2);
var templatePath = Path.Combine(templateDir, templateName);
template = new FileInfo(templatePath);
var templatePath2 = Path.Combine(templateDir, templateName2);
template2 = new FileInfo(templatePath2);
}
if (file.Exists || file2.Exists)
{
if (!file.Exists && file2.Exists)
{
file = file2;
fileFloor = fileFloor2;
relativePath = relativePath2;
}
using (var image = new Bitmap(Image.FromFile(file.FullName)))
{
if (originalFileBitmapSizeInTiles.HasValue && (originalFileBitmapSizeInTiles.Value.Width > 1 || originalFileBitmapSizeInTiles.Value.Height > 1))
{
Size rightSize = new Size(originalFileBitmapSizeInTiles.Value.Width * Program.MaxTileSize.Width, originalFileBitmapSizeInTiles.Value.Height * Program.MaxTileSize.Height);
if (image.Size != rightSize)
{
throw new WrongSizeException(image.Size, rightSize, string.Format("Image '{0}' should be {1}x{2} but is in reality {3}x{4}",
file.FullName, rightSize.Width, rightSize.Height, image.Width, image.Height));
}
Point pointInPixels = new Point(originalFilePointInTiles.Value.X * Program.MaxTileSize.Width, originalFilePointInTiles.Value.Y * Program.MaxTileSize.Height);
CropAndDrawImageToTileSet(image, pointInPixels, Program.MaxTileSize, file, flipHorizontal, flipVertical);
StoreTileFile(file, image.Size);
}
else
{
if (image.Size == Program.ItemSize)
{
var baseTileData = GetTileFile(originalTileNumber);
var floorTileData = baseTileData.FloorTileData;
FloorTileData floorTileDataReplacement = floorTileData != null ? new FloorTileData(fileFloor, floorTileData.HasTileFile, floorTileData.SubType, floorTileData.NameOrDesc) : null;
using (var floorImage = GetFloorTile(fileFloor, floorTileData, animation, frame))
{
DrawItemToTileSet(image, false, mainTileAlignment, floorImage);
StoreTileFile(file, image.Size, floorTileDataReplacement);
}
}
else if (image.Size == Program.MaxTileSize)
{
DrawImageToTileSet(image);
StoreTileFile(file, image.Size);
}
else
{
DrawMainTileToTileSet(image, widthInTiles, heightInTiles, mainTileAlignment, file);
StoreTileFile(file, image.Size);
}
}
}
Console.WriteLine("Compiled Animation '{0}' successfully.", relativePath);
WriteTileNameSuccess(relativePath);
}
else if (template != null && template2 != null && (template.Exists || template2.Exists))
{
if (!template.Exists && template2.Exists)
{
template = template2;
templateRelativePath = templateRelativePath2;
}
var templateData = originalTileData.TemplateData;
if (templateData == null)
{
throw new Exception(string.Format("TemplateData for Tile {0} is null.", originalTileNumber));
}
using (var image = CreateBitmapFromTemplate(template, templateData.TemplateColor, originalTileData.BitmapSize))
{
if (originalFileBitmapSizeInTiles.HasValue && (originalFileBitmapSizeInTiles.Value.Width > 1 || originalFileBitmapSizeInTiles.Value.Height > 1))
{
Size rightSize = new Size(originalFileBitmapSizeInTiles.Value.Width * Program.MaxTileSize.Width, originalFileBitmapSizeInTiles.Value.Height * Program.MaxTileSize.Height);
if (image.Size != rightSize)
{
throw new WrongSizeException(image.Size, rightSize, string.Format("Image '{0}' should be {1}x{2} but is in reality {3}x{4}",
template.FullName, rightSize.Width, rightSize.Height, image.Width, image.Height));
}
Point pointInPixels = new Point(originalFilePointInTiles.Value.X * Program.MaxTileSize.Width, originalFilePointInTiles.Value.Y * Program.MaxTileSize.Height);
CropAndDrawImageToTileSet(image, pointInPixels, Program.MaxTileSize, file, flipHorizontal, flipVertical);
StoreTileFile(template, image.Size);
}
else
{
if (image.Size == Program.ItemSize)
{
var floorTileData = originalTileData.FloorTileData;
FileInfo templateFloor = null;
FileInfo templateFloor2 = null;
if (floorTileData != null && floorTileData.FloorFile != null)
{
var floorFileWithoutExtension = Path.GetFileNameWithoutExtension(floorTileData.FloorFile.Name).ToFileName();
var templateDirFloor = Path.Combine(BaseDirectory.FullName, floorFileWithoutExtension);
var templateNameFloor = floorFileWithoutExtension + "_" + frame.ToFileName() + Program.ImageFileExtension;
var templateNameFloor2 = frame.ToFileName() + Program.ImageFileExtension;
var templatePathFloor = Path.Combine(templateDirFloor, templateNameFloor);
templateFloor = new FileInfo(templatePathFloor);
var templatePathFloor2 = Path.Combine(templateDirFloor, templateNameFloor2);
templateFloor2 = new FileInfo(templatePathFloor2);
if (!templateFloor.Exists && templateFloor2.Exists)
{
templateFloor = templateFloor2;
templateRelativePath = templateRelativePath2;
}
}
FloorTileData floorTileDataReplacement = floorTileData != null ? new FloorTileData(templateFloor, floorTileData.HasTileFile, floorTileData.SubType, floorTileData.NameOrDesc) : null;
using (var floorImage = GetFloorTileFromTemplate(templateFloor, templateData, floorTileData))
{
DrawItemToTileSet(image, false, mainTileAlignment, floorImage);
StoreTileFile(file, image.Size, floorTileDataReplacement);
}
}
else if (image.Size == Program.MaxTileSize)
{
DrawImageToTileSet(image);
StoreTileFile(file, image.Size);
}
else
{
DrawMainTileToTileSet(image, widthInTiles, heightInTiles, mainTileAlignment, file);
StoreTileFile(file, image.Size);
}
}
}
Console.WriteLine("Created Animation {0} from Template {1} successfully.", relativePath, templateRelativePath);
WriteTileNameTemplateGenerationSuccess(relativePath, templateRelativePath);
}
else
{
Console.WriteLine("File '{0}' not found. Creating Missing Animation.", file.FullName);
WriteTileNameErrorFileNotFound(relativePath, "Creating Missing Animation.");
using (var image = MissingAnimationCreator.CreateTile(_missingAnimationType, animation, frame))
{
DrawImageToTileSet(image);
}
}
IncreaseCurXY();
}
private Bitmap GetFloorTileFromTemplate(FileInfo templateFileFloor, TemplateData templateData, FloorTileData floorTileData)
{
if (templateFileFloor != null && templateFileFloor.Exists)
{
return(CreateItemFromTemplate(templateFileFloor, templateData.TemplateColor, templateData.SubTypeCode, templateData.SubTypeName));
}
else if (floorTileData.HasTileFile)
{
return(MissingAnimationFloorCreator.CreateTileWithTextLines(_missingFloorTileType, floorTileData.SubType, floorTileData.NameOrDesc.ToProperCaseFirst()));
}
else
{
return(null);
}
}
public override void CompileOne(string[] splitLine)
{
if (splitLine.Length < _lineLength)
{
throw new Exception(string.Format("Replacement line '{0}' has too few elements.", string.Join(',', splitLine)));
}
var replacementName = splitLine[1];
var tileName = splitLine[2];
var baseTileNumber = int.Parse(splitLine[3]); //Not used
int widthInTiles = int.Parse(splitLine[4]);
int heightInTiles = int.Parse(splitLine[5]);
int mainTileAlignmentInt = int.Parse(splitLine[6]);
if (!Enum.IsDefined(typeof(MainTileAlignment), mainTileAlignmentInt))
{
throw new Exception(string.Format("MainTileAlignment '{0}' is invalid. Should be 0 or 1.", mainTileAlignmentInt));
}
MainTileAlignment mainTileAlignment = (MainTileAlignment)mainTileAlignmentInt;
var dirPath = Path.Combine(BaseDirectory.FullName, replacementName.ToFileName());
var fileName = replacementName.ToFileName() + "_" + tileName.ToFileName() + Program.ImageFileExtension;
var filePath = Path.Combine(dirPath, fileName);
FileInfo file = new FileInfo(filePath);
var fileName2 = tileName.ToFileName() + Program.ImageFileExtension;
var filePath2 = Path.Combine(dirPath, fileName2);
FileInfo file2 = new FileInfo(filePath2);
var relativePath = Path.GetRelativePath(Program.InputDirectory.FullName, file.FullName);
var relativePath2 = Path.GetRelativePath(Program.InputDirectory.FullName, file2.FullName);
if (file.Exists || file2.Exists)
{
if (!file.Exists && file2.Exists)
{
fileName = fileName2;
filePath = filePath2;
file = file2;
relativePath = relativePath2;
}
Console.WriteLine("Compiled Replacement '{0}' successfully.", relativePath);
WriteTileNameSuccess(relativePath);
using (var image = new Bitmap(Image.FromFile(file.FullName)))
{
if (image.Size == Program.ItemSize)
{
var fileNameFloor = replacementName.ToFileName() + "_" + tileName.ToFileName() + _floorSuffix + Program.ImageFileExtension;
var filePathFloor = Path.Combine(dirPath, fileNameFloor);
FileInfo fileFloor = new FileInfo(filePathFloor);
var baseTileData = GetTileFile(baseTileNumber);
var floorTileData = baseTileData.FloorTileData;
FloorTileData floorTileDataReplacement = floorTileData != null ? new FloorTileData(fileFloor, floorTileData.HasTileFile, floorTileData.SubType, floorTileData.NameOrDesc) : null;
using (var floorImage = GetFloorTile(fileFloor, floorTileData, replacementName, tileName))
{
DrawItemToTileSet(image, false, mainTileAlignment, floorImage);
StoreTileFile(file, image.Size, floorTileDataReplacement);
}
}
else if (image.Size == Program.MaxTileSize)
{
DrawImageToTileSet(image);
StoreTileFile(file, image.Size);
}
else
{
DrawMainTileToTileSet(image, widthInTiles, heightInTiles, mainTileAlignment, file);
StoreTileFile(file, image.Size);
}
}
}
else
{
Console.WriteLine("File '{0}' and file '{1}' not found. Creating Missing Replacement Tile.", file.FullName, file2.FullName);
WriteTileNameErrorFileNotFound(relativePath + " OR " + relativePath2, "Creating Missing Replacement Tile.");
using (var image = MissingReplacementCreator.CreateTileWithTextLines(_missingReplacementType, replacementName, tileName))
{
DrawImageToTileSet(image);
}
}
IncreaseCurXY();
}
public Tile GetTile(FloorTileData t)
{
SetMinimapTile(Color.White);
return(new Floor(tilePosition));
}
protected void StoreTileFile(int subIndex, FileInfo file, Size bitmapSize, Point?pointInTiles, Size?bitmapSizeInTiles, bool isStatue = false, bool isFromTemplate = false, TemplateData templateData = null, FloorTileData floorTileData = null, bool flipHorizontal = false, bool flipVertical = false)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
var tileFileData = new TileData();
tileFileData.File = file;
tileFileData.PointInTiles = pointInTiles;
tileFileData.BitmapSizeInTiles = bitmapSizeInTiles;
tileFileData.IsStatue = isStatue;
tileFileData.IsFromTemplate = isFromTemplate;
tileFileData.TemplateData = templateData;
tileFileData.FloorTileData = floorTileData;
tileFileData.FlipHorizontal = flipHorizontal;
tileFileData.FlipVertical = flipVertical;
Program.TileFileData.Add(new Point(Program.CurrentCount, subIndex), tileFileData);
}
protected void StoreTileFile(FileInfo file, Size bitmapSize, Point?pointInTiles, Size?bitmapSizeInTiles, bool isStatue = false, bool isFromTemplate = false, TemplateData templateData = null, FloorTileData floorTileData = null, bool flipHorizontal = false, bool flipVertical = false)
{
StoreTileFile(0, file, bitmapSize, pointInTiles, bitmapSizeInTiles, isStatue, isFromTemplate, templateData, floorTileData, flipHorizontal, flipVertical);
}
protected void StoreTileFile(FileInfo file, Size bitmapSize, FloorTileData floorTileData)
{
StoreTileFile(file, bitmapSize, null, null, false, false, null, floorTileData);
}
protected void StoreTileFile(int subIndex, FileInfo file, Size bitmapSize, bool isStatue = false, bool isFromTemplate = false, TemplateData templateData = null, FloorTileData floorTileData = null)
{
StoreTileFile(subIndex, file, bitmapSize, null, null, isStatue, isFromTemplate, templateData);
}
