protected override void CutLayout()
{
img = new Texture2D(1, 1);
byte[] bytedata = File.ReadAllBytes(path);
img.LoadImage(bytedata);
Tiles_A1_Utility.A1_Tile_Slice_Water_Singleton(img, out wBlock, out hBlock, out mini_tile_w, out mini_tile_h, out sub_blocks_water);
sub_blocks_water_to_import = new List <bool>();
for (int i = 0; i < sub_blocks_water.Count / 3; i++)
{
sub_blocks_water_to_import.Add(false);
}
}
protected virtual void CutLayout()
{
img = new Texture2D(1, 1);
byte[] bytedata = File.ReadAllBytes(path);
img.LoadImage(bytedata);
//get the sliced part
Tiles_A1_Utility.A1_Tile_Slice_File(img, out wBlock, out hBlock, out mini_tile_w, out mini_tile_h, out sub_blocks_water, out sub_blocks_twister, out sub_blocks_floating);
sub_blocks_water_to_import = new List <bool>();
for (int i = 0; i < sub_blocks_water.Count / 3; i++)
{
sub_blocks_water_to_import.Add(false);
}
sub_blocks_floating_to_import = new List <bool>();
for (int i = 0; i < sub_blocks_floating.Count; i++)
{
sub_blocks_floating_to_import.Add(false);
}
sub_blocks_twister_to_import = new List <bool>();
foreach (var t in sub_blocks_twister)
{
sub_blocks_twister_to_import.Add(false);
}
waterFallFrame_Animation.Clear();
foreach (Texture2D block in sub_blocks_twister)
{
int tw = block.width;
int th = block.height / 3;
List <Texture2D> list = new List <Texture2D>();
for (int i = 0; i < 3; i++)
{
Color[] colors = block.GetPixels(0, th * (2 - i), tw, th);
Texture2D tmpT = new Texture2D(tw, th);
tmpT.SetPixels(0, 0, tw, th, colors);
tmpT.Apply();
list.Add(tmpT);
}
waterFallFrame_Animation.Add(list);
}
}
/// <summary>
/// Generate the selected water tile
/// </summary>
/// <param name="path"></param>
/// <param name="sub_blocks_water"></param>
/// <param name="sub_blocks_water_to_import"></param>
/// <param name="mini_tile_w"></param>
/// <param name="mini_tile_h"></param>
/// <param name="wBlock"></param>
/// <param name="hBlock"></param>
/// <param name="generate_sprite_sheet_image"></param>
public virtual void Generate_Water_Tiles(string path, List <Texture2D> sub_blocks_water, List <bool> sub_blocks_water_to_import,
int mini_tile_w, int mini_tile_h, int wBlock, int hBlock, bool generate_sprite_sheet_image)
{
//create the final directory for the auto tile
if (!Directory.Exists(Tiles_Utility.Auto_Tile_Folder_Path))
{
Directory.CreateDirectory(Tiles_Utility.Auto_Tile_Folder_Path);
}
//create the final directory for the generated Images
if (!Directory.Exists(Tiles_Utility.final_image_folder_path))
{
Directory.CreateDirectory(Tiles_Utility.final_image_folder_path);
}
//create the folder for that specific file image
string fileName = Path.GetFileNameWithoutExtension(path);
string loaded_file_image_path = string.Format(@"{0}/_{1}", Tiles_Utility.final_image_folder_path, fileName); //ex rtp_import\Outside_A2\single_block_folder\final_tile\Image
if (!Directory.Exists(loaded_file_image_path))
{
Directory.CreateDirectory(loaded_file_image_path);
}
List <string> images_path = new List <string>();//list of the folder of the imported tiles
Dictionary <byte, int> rule_tiles = new Dictionary <byte, int>();
//foreach sub pieces in the image. If it's an animated auto tile 3 consecutive sub blocks are 3 frame of the animation
for (int sub_block_count = 0; sub_block_count < sub_blocks_water_to_import.Count; sub_block_count++)
{
//If the current sub is not selected to process than skip it
if (!sub_blocks_water_to_import[sub_block_count])
{
continue;
}
for (int i = sub_block_count * 3; i < sub_block_count * 3 + 3; i++)
{
int tiles_counter = 0; //set zero to che final tile counter
Texture2D sub_piece = sub_blocks_water[i];
//temp array to store the sub mini tiles
Texture2D[] bottom_left_mini_tiles, bottom_right_mini_tiles, top_left_mini_tiles, top_right_mini_tiles;
//generate the mini tiles to the following computation
Tiles_A1_Utility.Generate_Mini_Tile_A1Water(sub_piece, mini_tile_w, mini_tile_h, out bottom_left_mini_tiles, out bottom_right_mini_tiles, out top_left_mini_tiles, out top_right_mini_tiles);
if (generate_sprite_sheet_image)
{
Texture2D sprite_tiles = new Texture2D(wBlock * 8, hBlock * 6);
string sprite_sheet_path = string.Format(@"{0}/_Water_{1}_{2}.png", loaded_file_image_path, Path.GetFileNameWithoutExtension(path), i);
//generate and iterate the final tile for the subs pieces
foreach (KeyValuePair <byte, Texture2D> kvp in Tiles_A1_Utility.Generate_Final_Tiles_A1_Water(mini_tile_w, mini_tile_h,
bottom_left_mini_tiles, bottom_right_mini_tiles, top_left_mini_tiles, top_right_mini_tiles, rule_tiles))
{
int xx = tiles_counter % 8 * wBlock;
int yy = tiles_counter / 8 * hBlock;
sprite_tiles.SetPixels(xx, sprite_tiles.height - yy - hBlock, wBlock, hBlock, kvp.Value.GetPixels());
tiles_counter++;
}
images_path.Add(sprite_sheet_path);
File.WriteAllBytes(sprite_sheet_path, sprite_tiles.EncodeToPNG());
AssetDatabase.Refresh();
TextureImporter importer = AssetImporter.GetAtPath(sprite_sheet_path) as TextureImporter;
if (importer != null)
{
importer.textureType = TextureImporterType.Sprite;
importer.spriteImportMode = SpriteImportMode.Multiple;
importer.filterMode = FilterMode.Point;
importer.spritePixelsPerUnit = hBlock;
importer.compressionQuality = 0;
importer.maxTextureSize = sprite_tiles.width;
SpriteMetaData[] tmps = new SpriteMetaData[8 * 6];
string tmpName = Path.GetFileNameWithoutExtension(sprite_sheet_path);
for (int j = 0; j < 48; j++)
{
int xx = j % 8 * wBlock;
int yy = (j / 8 + 1) * hBlock;
SpriteMetaData smd = new SpriteMetaData();
smd = new SpriteMetaData();
smd.alignment = 0;
smd.border = new Vector4(0, 0, 0, 0);
smd.name = string.Format("{0}_{1:00}", tmpName, j);
smd.pivot = new Vector2(.5f, .5f);
smd.rect = new Rect(xx, sprite_tiles.height - yy, wBlock, hBlock);
tmps[j] = smd;
}
importer.spritesheet = tmps;
importer.SaveAndReimport();
}
}
else
{
//create the directory for the final images
string tile_folder_path = string.Format(@"{0}/_Water_{1}_{2}", loaded_file_image_path, Path.GetFileNameWithoutExtension(path), i);
//add the path of the this that will contains alla the sub block final tiles
images_path.Add(tile_folder_path);
if (!Directory.Exists(tile_folder_path))
{
Directory.CreateDirectory(tile_folder_path);
}
//generate and iterate the final tile for the subs pieces
foreach (KeyValuePair <byte, Texture2D> kvp in Tiles_A1_Utility.Generate_Final_Tiles_A1_Water(mini_tile_w, mini_tile_h,
bottom_left_mini_tiles, bottom_right_mini_tiles, top_left_mini_tiles, top_right_mini_tiles, rule_tiles))
{
//save each final tile to its own image
var tile_bytes = kvp.Value.EncodeToPNG();
string tile_file_path = string.Format(@"{0}/_Water_{1}_{2}_{3:000}.png", tile_folder_path,
Path.GetFileNameWithoutExtension(path), sub_block_count, tiles_counter);
File.WriteAllBytes(tile_file_path, tile_bytes);
tiles_counter++;
}
}
}
}
AssetDatabase.Refresh(); //refresh asset database
//generate the fixed Auto tiles
for (int i = 0; i < images_path.Count; i += 3)
{
if (generate_sprite_sheet_image)
{
Tiles_A1_Utility.Generate_A1_Water_Tile_SS(path, images_path[i], images_path[i + 1], images_path[i + 2], rule_tiles, wBlock);
}
else
{
Tiles_A1_Utility.Generate_A1_Water_Tile(path, images_path[i], images_path[i + 1], images_path[i + 2], rule_tiles, wBlock);
}
}
}
/// <summary>
/// Generate all the final tiles combination for the A1 Water tile, the A3 terrai and A4 top-celing tile,
/// and set up other collection to generate rule tiles etc
/// </summary>
/// <param name="bottom_left_mini_tiles"></param>
/// <param name="bottom_right_mini_tiles"></param>
/// <param name="top_left_mini_tiles"></param>
/// <param name="top_right_mini_tiles"></param>
/// <param name="rule_tiles"></param>
/// <returns></returns>
public static Dictionary <byte, Texture2D> Generate_Final_Tiles_A2_Terrain(int mini_tile_w, int mini_tile_h, Texture2D[] bottom_left_mini_tiles, Texture2D[] bottom_right_mini_tiles,
Texture2D[] top_left_mini_tiles, Texture2D[] top_right_mini_tiles, Dictionary <byte, int> rule_tiles)
{
return(Tiles_A1_Utility.Generate_Final_Tiles_A1_Water(mini_tile_w, mini_tile_h, bottom_left_mini_tiles, bottom_right_mini_tiles, top_left_mini_tiles, top_right_mini_tiles, rule_tiles));
}
/// <summary>
/// Select the correct mini tile for the combination/value.
/// WORK WITH THE A1 Water Like Tile (NOT THE WATER FALL OR TWISTER), FOR THE TERRAIN AND THE A4 TOP-CEALING TILE
/// This is the MAGIC to generate the final tiles. DO NOT TOUCH PLEASE
/// </summary>
/// <param name="value"></param>
/// <param name="b1"></param>
/// <param name="b2"></param>
/// <param name="b3"></param>
/// <param name="bx"></param>
/// <param name="by"></param>
/// <returns></returns>
public static int Select_Mini_Tile_A2_Terrain(byte value, int b1, int b2, int b3, int bx, int by)
{
return(Tiles_A1_Utility.Select_Mini_Tile_A1Water(value, b1, b2, b3, bx, by));
}
/// <summary>
/// Split a single sub block into tne mini tile to be reworked
/// </summary>
/// <param name="img">sub block to be reworked. It MUST be an A1 Water Tile, A2 Terrain or A3 TOP-cealing tile</param>
/// <param name="wBlock">width of the mini tile block</param>
/// <param name="hBlock">height of the mini tile block</param>
/// <param name="bottom_left_mini_tiles">destination array</param>
/// <param name="bottom_right_mini_tiles">destination array/param>
/// <param name="top_left_mini_tiles">destination array</param>
/// <param name="top_right_mini_tiles">destination array</param>
public static void Generate_Mini_Tile_A2(Texture2D img, int wBlock, int hBlock,
out Texture2D[] bottom_left_mini_tiles, out Texture2D[] bottom_right_mini_tiles,
out Texture2D[] top_left_mini_tiles, out Texture2D[] top_right_mini_tiles)
{
Tiles_A1_Utility.Generate_Mini_Tile_A1Water(img, wBlock, hBlock, out bottom_left_mini_tiles, out bottom_right_mini_tiles, out top_left_mini_tiles, out top_right_mini_tiles);
}
void OnGUI()
{
generate_sprite_sheet_image = GUILayout.Toggle(generate_sprite_sheet_image, "Generate Sprite Sheet Image");
if (GUILayout.Button("Load Image"))
{
path = EditorUtility.OpenFilePanel("Load Tile Set", ".", "*.*");
if (path != null && path != "" && File.Exists(path) && path.Contains("A1"))
{
img = new Texture2D(1, 1);
byte[] bytedata = File.ReadAllBytes(path);
img.LoadImage(bytedata);
//get the sliced part
Tiles_A1_Utility.A1_Tile_Slice_File(img, out wBlock, out hBlock, out mini_tile_w, out mini_tile_h, out sub_blocks_water, out sub_blocks_twister, out sub_blocks_floating);
sub_blocks_water_to_import = new List <bool>();
for (int i = 0; i < sub_blocks_water.Count / 3; i++)
{
sub_blocks_water_to_import.Add(false);
}
sub_blocks_floating_to_import = new List <bool>();
for (int i = 0; i < sub_blocks_floating.Count; i++)
{
sub_blocks_floating_to_import.Add(false);
}
sub_blocks_twister_to_import = new List <bool>();
foreach (var t in sub_blocks_twister)
{
sub_blocks_twister_to_import.Add(false);
}
}
else
{
if (path != null && path != "")
{
EditorUtility.DisplayDialog("Selection error!", "You have to select a file or an A1 file compatibile with RPG MAKER tile set", "OK");
}
}
}
if (img == null)
{
return;
}
if (GUILayout.Button("Generate Tiles"))
{
//generate the floating tile. They are A2 style tile
A2_Tiles_Importer_Window.Generate_Tiles(path, sub_blocks_floating, sub_blocks_floating_to_import,
mini_tile_w, mini_tile_h, wBlock, hBlock, generate_sprite_sheet_image);
//generate waterfall tile style
Generate_Twister_Tiles(path, sub_blocks_twister, sub_blocks_twister_to_import,
mini_tile_w, mini_tile_h, wBlock, hBlock, generate_sprite_sheet_image);
//generate the animated A1 style tile
Generate_Water_Tiles(path, sub_blocks_water, sub_blocks_water_to_import,
mini_tile_w, mini_tile_h, wBlock, hBlock, generate_sprite_sheet_image);
}
GUILayout.Label("Select the tile you want to import, then click the 'Generate Tiles' Button");
scrollPosition = GUILayout.BeginScrollView(scrollPosition, true, true, GUI.skin.horizontalScrollbar, GUI.skin.verticalScrollbar);
GUILayout.BeginVertical();
GUILayout.Space(10);
GUILayout.Label("Animated Water Tile");
GUILayout.BeginHorizontal();
for (int i = 0; i < sub_blocks_water.Count; i += 3)
{
Texture2D sub_water = sub_blocks_water[i];
sub_blocks_water_to_import[i / 3] = GUILayout.Toggle(sub_blocks_water_to_import[i / 3], sub_water);
}
GUILayout.EndHorizontal();
GUILayout.Label("Animated Water fall/twister Tile");
GUILayout.BeginHorizontal();
for (int i = 0; i < sub_blocks_twister.Count; i += 1)
{
Texture2D sub_twister = sub_blocks_twister[i];
sub_blocks_twister_to_import[i] = GUILayout.Toggle(sub_blocks_twister_to_import[i], sub_twister);
}
GUILayout.EndHorizontal();
GUILayout.Label("Floating element Tile");
GUILayout.BeginHorizontal();
for (int i = 0; i < sub_blocks_floating.Count; i += 1)
{
Texture2D sub_float = sub_blocks_floating[i];
sub_blocks_floating_to_import[i] = GUILayout.Toggle(sub_blocks_floating_to_import[i], sub_float);
}
GUILayout.EndHorizontal();
GUILayout.EndVertical();
GUILayout.EndScrollView();
}
