public static int Select_Mini_Tile_A3_Wall(byte value, int b1, int b2, int b3, int b4)
{
bool bit1 = Tiles_Utility.GetBit(value, b1);
bool bit2 = Tiles_Utility.GetBit(value, b2);
bool bit3 = Tiles_Utility.GetBit(value, b3);
//bool bitX = GetBit(value, bx);
//bool bitY = GetBit(value, by);
//corner
if (!bit1 && !bit3)
{
return(0); //mini_tiles[0];//corner
}
//center
if (bit1 && bit2 && bit3)
{
return(8);
}
if (!bit1 && bit3)
{
return(6);
}
//up side
if (bit1 && !bit3)
{
return(2);
}
return(8); //mini_tiles[4];//mini_tiles[9];//tip
}
/// <summary>
/// Generate the A2_Tile or the A4Top tiles from the single image tile
/// </summary>
/// <param name="tile_path">Path of the dir where the single image are located</param>
/// <param name="rule_tiles">Rule to create the tile</param>
/// <param name="wBlock">width of the block</param>
public static void Generate_A4_Tile(string source_File_Path, string tile_path, Dictionary <byte, int> rule_tiles, int wBlock)
{
//create the auto tile
string atile_path = string.Format(@"{0}/_{1}/{2}.asset", Tiles_Utility.Auto_Tile_Folder_Path, Path.GetFileNameWithoutExtension(source_File_Path),
Path.GetFileNameWithoutExtension(tile_path));
string dir = string.Format(@"{0}/{1}", Tiles_Utility.Auto_Tile_Folder_Path, Path.GetFileNameWithoutExtension(source_File_Path));
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
A4_Top_Tile atile = ScriptableObject.CreateInstance <A4_Top_Tile>();
if (File.Exists(atile_path))
{
atile = AssetDatabase.LoadAssetAtPath <A4_Top_Tile>(atile_path);
}
EditorUtility.SetDirty(atile);
if (atile != null)
{
atile.tile_Variants = new Sprite[rule_tiles.Count];
string[] tiles = Directory.GetFiles(tile_path, "*.png");
foreach (var fTile in tiles)
{
//set the image importer setting
Tiles_Utility.Set_Impoter_Settings(fTile, wBlock);
}
int cc = 0;
//StreamWriter myFile = new StreamWriter(@"C:\tmp\file.txt");
foreach (var kvp in rule_tiles)
{
Sprite tmp = AssetDatabase.LoadAssetAtPath <Sprite>(tiles[kvp.Value]);
if (cc == 0) //setting the sprite for the tile palette
{
cc++;
atile.sprite = tmp;
atile.preview = tmp;
}
atile.tile_Variants[kvp.Key] = tmp;
//myFile.WriteLine(string.Format("{0},{1}", kvp.Key, kvp.Value));
}
//myFile.Close();
}
if (File.Exists(atile_path))
{
AssetDatabase.SaveAssets();
}
else
{
AssetDatabase.CreateAsset(atile, atile_path);
}
}
/// <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="bl"></param>
/// <param name="br"></param>
/// <returns></returns>
public static int Select_Mini_Tile_A1_Twister(byte value, int b1)
{
bool bitl = Tiles_Utility.GetBit(value, b1);
//corner
if (!bitl)
{
return(0); //mini_tiles[0];//corner
}
return(2);
}
/// <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(byte value, int b1, int b2, int b3, int bx, int by)
{
bool bit1 = Tiles_Utility.GetBit(value, b1);
bool bit2 = Tiles_Utility.GetBit(value, b2);
bool bit3 = Tiles_Utility.GetBit(value, b3);
bool bitX = Tiles_Utility.GetBit(value, bx);
bool bitY = Tiles_Utility.GetBit(value, by);
//corner
if (!bit1 && !bit3)
{
return(0); //mini_tiles[0];//corner
}
//center
if (bit1 && bit2 && bit3)
{
return(8);
}
if (!bit1 && bit3)
{
if (bitX)
{
return(3);
}
else
{
return(6);
}
}
//up side
if (bit1 && !bit3)
{
if (bitY)
{
return(1);
}
else
{
return(2);
}
}
if (bit1 && !bit2 && bit3)
{
return(9); //mini_tiles[9];//tip
}
return(4); //mini_tiles[4];
}
/// <summary>
/// Generate the twister/water fall final tile
/// </summary>
/// <param name="mini_tile_w"></param>
/// <param name="mini_tile_h"></param>
/// <param name="left_mini_tiles"></param>
/// <param name="right_mini_tiles"></param>
/// <param name="rule_tiles"></param>
/// <returns></returns>
public static List <Texture2D> Generate_Final_Tiles_A1_Twister(int mini_tile_w, int mini_tile_h, Texture2D[,] left_mini_tiles, Texture2D[,] right_mini_tiles, Dictionary <byte, int> rule_tiles)
{
List <Texture2D> final_pieces = new List <Texture2D>(); //pezzi finali da considerare per la creazione dell'immagine
rule_tiles.Clear(); //lista delle regole di assegnamento
List <string> used_Combination = new List <string>(); //dictionary of used combinations
for (int i = 0; i < 3; i++)
{
foreach (var comb in Tiles_Utility.Left_Right_Combination())
{
Texture2D tmp = new Texture2D(mini_tile_w * 2, mini_tile_h); //to make parametric
#region DO NOT TOUCH! This is the magic
int l = Select_Mini_Tile_A1_Twister(comb, 5);
int r = Select_Mini_Tile_A1_Twister(comb, 4);
tmp.SetPixels(0, 0, mini_tile_w, mini_tile_h, left_mini_tiles[i, l].GetPixels());
tmp.SetPixels(mini_tile_w, 0, mini_tile_w, mini_tile_h, right_mini_tiles[i, r].GetPixels());
tmp.Apply();
#endregion
string key = string.Format("{0}{1}", l, r);
if (!used_Combination.Contains(key))
{
used_Combination.Add(key); //salvo le key degli sprite usate
}
final_pieces.Add(tmp);
int index = used_Combination.IndexOf(key); //retrive the index
if (!rule_tiles.ContainsKey(comb))
{
rule_tiles.Add(comb, index);
}
}
}
return(final_pieces);
}
/// <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_A1_Water(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)
{
Dictionary <byte, Texture2D> final_pieces = new Dictionary <byte, Texture2D>(); //pezzi finali da considerare per la creazione dell'immagine
rule_tiles.Clear(); //lista delle regole di assegnamento
List <string> used_Combination = new List <string>(); //dictionary of used combinations
foreach (var comb in Tiles_Utility.ByteCombination())
{
Texture2D tmp = new Texture2D(mini_tile_w * 2, mini_tile_h * 2); //to make parametric
#region DO NOT TOUCH! This is the magic
int bl = Select_Mini_Tile_A1Water(comb, 5, 8, 7, 2, 4);
int br = Select_Mini_Tile_A1Water(comb, 7, 6, 4, 5, 2);
int tr = Select_Mini_Tile_A1Water(comb, 4, 1, 2, 7, 5);
int tl = Select_Mini_Tile_A1Water(comb, 2, 3, 5, 4, 7);
tmp.SetPixels(0, 0, mini_tile_w, mini_tile_h, bottom_left_mini_tiles[bl].GetPixels());
tmp.SetPixels(mini_tile_w, 0, mini_tile_w, mini_tile_h, bottom_right_mini_tiles[br].GetPixels());
tmp.SetPixels(0, mini_tile_h, mini_tile_w, mini_tile_h, top_left_mini_tiles[tl].GetPixels());
tmp.SetPixels(mini_tile_w, mini_tile_h, mini_tile_w, mini_tile_h, top_right_mini_tiles[tr].GetPixels());
tmp.Apply();
#endregion
string key = string.Format("{0}{1}{2}{3}", bl, br, tl, tr);
if (!used_Combination.Contains(key))
{
used_Combination.Add(key); //salvo le key degli sprite usate
final_pieces.Add(comb, tmp);
}
int index = used_Combination.IndexOf(key); //retrive the index
rule_tiles.Add(comb, index);
}
return(final_pieces);
}
/// <summary>
/// Generate the A1 water fall tile from the single images tile
/// </summary>
/// <param name="source_File_Path"></param>
/// <param name="frame1"></param>
/// <param name="rule_tiles"></param>
/// <param name="wBlock"></param>
public static void Generate_A1_Twister_Tile(string source_File_Path, string tiles_folder, Dictionary <byte, int> rule_tiles, int wBlock)
{
//create the auto tile for the animation water
string atile_path = string.Format(@"{0}/_{1}/{2}.asset", Tiles_Utility.Auto_Tile_Folder_Path, Path.GetFileNameWithoutExtension(source_File_Path),
Path.GetFileNameWithoutExtension(tiles_folder));
string dir = string.Format(@"{0}/_{1}", Tiles_Utility.Auto_Tile_Folder_Path, Path.GetFileNameWithoutExtension(source_File_Path));
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
//A1_Water_Tile atile = new A1_Water_Tile();
A1_WaterFall_Tile atile = ScriptableObject.CreateInstance <A1_WaterFall_Tile>();
atile.animation_Speed = 4; //this is a base value for a nice speed animation
if (File.Exists(atile_path))
{
atile = AssetDatabase.LoadAssetAtPath <A1_WaterFall_Tile>(atile_path);
}
EditorUtility.SetDirty(atile);
if (atile != null)
{
atile.frame1 = new Sprite[256];
atile.frame2 = new Sprite[256];
atile.frame3 = new Sprite[256];
string[] tiles = Directory.GetFiles(tiles_folder, "*.png");
foreach (var fTile in tiles)
{
//set the image importer setting
Tiles_Utility.Set_Impoter_Settings(fTile, wBlock);
}
int cc = 0;
foreach (var kvp in rule_tiles)
{
Sprite tmp1 = AssetDatabase.LoadAssetAtPath <Sprite>(tiles[kvp.Value]) as Sprite;
Sprite tmp2 = AssetDatabase.LoadAssetAtPath <Sprite>(tiles[kvp.Value + 4]) as Sprite;
Sprite tmp3 = AssetDatabase.LoadAssetAtPath <Sprite>(tiles[kvp.Value + 8]) as Sprite;
if (cc == 0) //setting the sprite for the tile palette
{
cc++;
atile.sprite = tmp1;
atile.preview = tmp1;
}
atile.frame1[kvp.Key] = tmp1;
atile.frame2[kvp.Key] = tmp2;
atile.frame3[kvp.Key] = tmp3;
}
}
if (File.Exists(atile_path))
{
AssetDatabase.SaveAssets();
}
else
{
AssetDatabase.CreateAsset(atile, atile_path);
}
}
/// <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(byte value, int b1, int b2, int b3, int bx, int by, int bz)
{
bool bit1 = Tiles_Utility.GetBit(value, b1);
bool bit2 = Tiles_Utility.GetBit(value, b2);
bool bit3 = Tiles_Utility.GetBit(value, b3);
bool bitX = Tiles_Utility.GetBit(value, bx);
bool bitY = Tiles_Utility.GetBit(value, by);
bool bitZ = Tiles_Utility.GetBit(value, bz);
//corner
if (!bit1 && !bit3)
{
return(0); //mini_tiles[0];//corner
}
//center
if (bit1 && bit2 && bit3 && bitX && bitY && bitZ)
{
return(4);
}
else if (bit1 && bit2 && bit3 && !bitX && !bitY && !bitZ) //angolo con i vicini a left and bottom uguali, vicini right and up diversi
{
return(8);
}
else if (bit1 && bit2 && bit3 && !bitX && bitY) //angolo con i vicini a left and bottom uguali, sopra diverso right uguali
{
return(7);
}
else if (bit1 && bit2 && bit3 && bitX && !bitY) //angolo con i vicini a left and bottom uguali, sopra ugiali right doversi
{
return(5);
}
if (!bit1 && bit3)
{
if (bitX)
{
return(3);
}
else
{
return(6);
}
}
//up side
if (bit1 && !bit3)
{
if (bitY)
{
return(1);
}
else
{
return(2);
}
}
if (bit1 && !bit2 && bit3)
{
return(9); //mini_tiles[9];//tip
}
return(4); //mini_tiles[4];
}
