using System;

public class Program {

    public struct Tile {

        public int _Type;

    }

    public class World {

​

        public int _Max_X, _Max_Y, _Max_Z;

        public int _Max_X_pow, _Max_Y_pow, _Max_Z_pow;

        public int _Shift_X, _Shift_Y;

        public int _Mask_X, _Mask_Y, _Mask_Z;

        public int _Tmp_Mult_YZ;

        //public Tile[] _Tiles;

        public World() {

            _Max_X_pow=11;

            _Max_Y_pow=4;

            _Max_Z_pow=11;

            _Shift_X = _Max_Z_pow + _Max_Y_pow;

            _Shift_Y = _Max_Z_pow;

            _Max_X = (int) Math.Pow(2,_Max_X_pow);

            _Max_Y = (int) Math.Pow(2,_Max_Y_pow);

            _Max_Z = (int) Math.Pow(2,_Max_Z_pow);

            /*

            _Max_X = 1600;

            _Max_Y = 10;

            _Max_Z = 1600;

            */

            //_Tiles = new Tile[_Max_X * _Max_Y * _Max_Z];

            _Tmp_Mult_YZ = _Max_Y * _Max_Z;

            _Mask_X = (_Max_X - 1) << _Shift_X;

            _Mask_Y = (_Max_Y - 1) << _Shift_Y;

            _Mask_Z = (_Max_Z - 1);

        }

        //public Tile Get_Tile(int index) { 

        //  return _Tiles[index];

        //}

        public int Get_Tile_Index(int x, int y, int z) {

            return x << _Shift_X | y << _Shift_Y | z;

        }

        public int Get_Tile_Index_Old(int x, int y, int z) {

            return x * _Max_Y * _Max_Z + y * _Max_Z + z;

        }

        public void Get_Tile_Coords_By_Index(int index, out int x, out int y, out int z) {

            x = (index &  _World._Mask_X) >> _World._Shift_X;

            y = (index & _World._Mask_Y) >> _World._Shift_Y;

            z = index & _World._Mask_Z;

            /*

            string binary_index = Convert.ToString( _World._Mask_X, 2).PadLeft(32, '0');

            Console.WriteLine(binary_index + " | " +  _World._Mask_X + " - Mask to X");

            binary_index = Convert.ToString(x, 2).PadLeft(32, '0');

            Console.WriteLine(binary_index + " | " + x + " - Masked X");

​

            binary_index = Convert.ToString(_World._Mask_Y, 2).PadLeft(32, '0');

            Console.WriteLine(binary_index + " | " + _World._Mask_Y + " - Mask to Y");

            binary_index = Convert.ToString(y, 2).PadLeft(32, '0');

            Console.WriteLine(binary_index + " | " + y + " - Masked Y");

​

            binary_index = Convert.ToString(_World._Mask_Z, 2).PadLeft(32, '0');

            Console.WriteLine(binary_index + " | " + _World._Mask_Z + " - Mask to Z");

            binary_index = Convert.ToString(z, 2).PadLeft(32, '0');

            Console.WriteLine(binary_index + " | " + z + " - Masked Z");

            */

        }

        //Мой старый вариант обратного разложения координат, работает в 4 раза медленней бинарного но куда менее ограничен в диапазоне чисел

        public void Get_Tile_Coords_By_Index_Old(int index, out int x, out int y, out int z) {

            float tmp_X_val = index / _Tmp_Mult_YZ;

            x = (int)(tmp_X_val + 32768.0f) - 32768; //(int)(tmp_X_val + 32768.0f) - 32768 это тоже самое что и Mathf.FloorToInt() для диапазона short, но работает в разы быстрее

​

            int shift = x * _Tmp_Mult_YZ;

            float tmp_Y_val = (index - shift) / _Max_Z;

            y = (int)(tmp_Y_val + 32768.0f) - 32768;

​

            z = index - (shift + y * _Max_Z);

        }

    }

    public static World _World;

    public static void Main() {

        _World = new World();

        int trg_x = 64;

        int trg_y = 15;

        int trg_z = 42;

        //Вот мы получили индекс по координатам...

        int random_tile_index = _World.Get_Tile_Index(trg_x,trg_y,trg_z);

        int random_tile_index_Old = _World.Get_Tile_Index_Old(trg_x,trg_y,trg_z);

        //...вот мы получили тайл по индексу... все замечательно... но...

        //Tile random_tile = _World.Get_Tile(random_tile_index);

        //...как сделать обратное преобразование?

        int x, y, z, old_x, old_y, old_z;

        _World.Get_Tile_Coords_By_Index(random_tile_index, out x, out y, out z);

        _World.Get_Tile_Coords_By_Index_Old(random_tile_index_Old, out old_x, out old_y, out old_z);

        Console.WriteLine("---------- Coords ----------");

        Console.WriteLine(string.Format("Max_XYZ: {0}|{1}|{2}", _World._Max_X, _World._Max_Y, _World._Max_Z));

        Console.WriteLine(string.Format("Target_XYZ: {0}|{1}|{2}", trg_x, trg_y, trg_z));

        Console.WriteLine(string.Format("Coords_To_Index: {0} - New", random_tile_index));

        Console.WriteLine(string.Format("Coords_To_Index: {0} - Old", random_tile_index_Old));

        Console.WriteLine(string.Format("Index_To_Coords: {0}|{1}|{2} - New", x,y,z));

        Console.WriteLine(string.Format("Index_To_Coords: {0}|{1}|{2} - Old", old_x,old_y,old_z));

        Console.WriteLine("");

        Console.WriteLine("---------- Binary_Colibration ----------");

        string binary_str = Convert.ToString(random_tile_index, 2).PadLeft(32, '0');

        Console.WriteLine(binary_str + " | " + random_tile_index + " - Index");

        int max_index = _World._Max_X * _World._Max_Y * _World._Max_Z;

        binary_str = Convert.ToString(max_index, 2).PadLeft(32, '0');

        Console.WriteLine(string.Format("{0} | {1} - Max_Index", binary_str, max_index));

        Console.WriteLine("");

        Console.WriteLine("---------- Binary_Splitting ----------");

        int bin_x = (random_tile_index &  _World._Mask_X) >> _World._Shift_X;

        binary_str = Convert.ToString( _World._Mask_X, 2).PadLeft(32, '0');

        Console.WriteLine(string.Format("{0} | {1} - Mask to X", binary_str,  _World._Mask_X));

        binary_str = Convert.ToString(bin_x, 2).PadLeft(32, '0');

        Console.WriteLine(string.Format("{0} | {1} - Masked X", binary_str,  bin_x));

        int bin_y = (random_tile_index & _World._Mask_Y) >> _World._Shift_Y;

        binary_str = Convert.ToString(_World._Mask_Y, 2).PadLeft(32, '0');

        Console.WriteLine(string.Format("{0} | {1} - Mask to Y", binary_str,  _World._Mask_Y));

        binary_str = Convert.ToString(bin_y, 2).PadLeft(32, '0');

        Console.WriteLine(string.Format("{0} | {1} - Masked Y", binary_str,  bin_y));

​

        int bin_z = random_tile_index & _World._Mask_Z;

        binary_str = Convert.ToString(_World._Mask_Z, 2).PadLeft(32, '0');

        Console.WriteLine(string.Format("{0} | {1} - Mask to Z", binary_str,  _World._Mask_Z));

        binary_str = Convert.ToString(bin_z, 2).PadLeft(32, '0');

        Console.WriteLine(string.Format("{0} | {1} - Masked Z", binary_str,  bin_z));

        Console.WriteLine("");

        Console.WriteLine("---------- Speed Test ----------");

        System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();

        int try_count = 1000000;

        sw.Restart();

        for(int i = 0; i < try_count; i++) {

            _World.Get_Tile_Index(64,15,42);

        }

        sw.Stop();

        Console.WriteLine("Get_Index_New: " + sw.Elapsed);

        sw.Restart();

        for(int i = 0; i < try_count; i++) {

            _World.Get_Tile_Index_Old(64,15,42);

        }

        sw.Stop();

        Console.WriteLine("Get_Index_Old: " + sw.Elapsed);

        sw.Restart();

        for(int i = 0; i < try_count; i++) {

            _World.Get_Tile_Coords_By_Index(random_tile_index, out x, out y, out z);

        }

        sw.Stop();

        Console.WriteLine("Get_Coords_New: " + sw.Elapsed);

        sw.Restart();

        for(int i = 0; i < try_count; i++) {

            _World.Get_Tile_Coords_By_Index_Old(random_tile_index, out x, out y, out z);

        }

        sw.Stop();

        Console.WriteLine("Get_Coords_Old: " + sw.Elapsed);

    }

}