int* buf=(int*)malloc(4);

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

struct Brick {
	unsigned short isSet : 3;
	unsigned short Damage : 4;
	unsigned short Matherial : 8;
};


int* buf=(int*)malloc(8);//сразу выделил память на два элемента: 1.value 2.Код координаты
int* c_buf = buf;
unsigned long int pow_buf = 2;

void setBrick(int x, int y, int z, int value)
{
	//записываем значения
	*c_buf++ = value;
	*c_buf++ = x + (y << 10) + (z << 20);//код координаты
	//выделяю память на следующий элемент
	pow_buf += 2;
	buf = (int*)realloc(buf, 2 + (pow_buf)* 4);
}

int getBrick(int x, int y, int z)
{
	for (int i = 1; i<pow_buf-2; i += 2)//иду по чётным элементам(по кодам координат)
	{
		if (*(buf + i) == x + (y << 10) + (z << 20))
		{
			return *(buf + i-1);
		}
	}
	return -1;//в случае неудачи
}


int main(int argc, char** argv)
{
	printf("Test setBrick()\n");
	setBrick(0, 0, 0, 125);
	setBrick(1023, 1024, 1023, 5678);
	setBrick(125, 512, 512, 10678);
	setBrick(125, 512, 512, 12678);
	for (int i = 0; i < pow_buf-2; i++)
	{
		printf("%i\n", *(buf+i));
	}
	printf("\nTest getBrick()");
	printf("\n%i ", getBrick(125, 125, 125));
	printf("\n%i \n", getBrick(125, 512, 512));
	
	free(buf);
}

int* buf=(int*)malloc(12);//сразу выделил память на два элемента: 1.value 2.Код координаты
int* c_buf = buf;
unsigned long int pow_buf = 3;
unsigned int pow_block = 3;


int setBrick(int x, int y, int z, int value)
{
	//Проверка на то что такой элемент с такими координатами уже существует
	for (int i = 0; i < pow_buf - pow_block; i += pow_block)//иду по блокам
	{
		if (*(buf + i + 1) == x + (y << 10) + (z << 20))//сравниваю координаты
		{
			printf("\n(%i  %i  %i)This item already exists \n",x,y,z);
			return -1;
		}
	}

	//Индексация
	int new_index = (pow_buf-pow_block)/pow_block;//максимальный текущий индекс
	for (int i = 0; i < pow_buf - pow_block; i += pow_block)//иду по блокам
	{
		if (*(buf + i)>value)
		{
			if (*(buf + i + 2) < new_index)
			{
				new_index = *(buf + i + 2);
			}
			*(buf + i + 2)+=1;//перестраиваю индекс элемента
		}
	}
	*(c_buf + 2) = (new_index == (pow_buf - pow_block) / pow_block) ? new_index + 1 : new_index;//индекс нового элемента

	*c_buf = value;
	*(c_buf+1) = x + (y << 10) + (z << 20);//код координаты
	//выделяю память на следующий элемент
	pow_buf += pow_block;
	c_buf += 3;
	buf = (int*)realloc(buf, pow_buf* 4);
	return 1;
}

//Выделяю память на два элемента: 1.value 2.код координаты
unsigned long int count_block = 1;//количество блоков в основном массиве с парами значение-код координаты
unsigned long int up_block = count_block - 1;
unsigned int pow_block = 2;//мощность одного блока основго массива
int* buf=(int*)malloc(count_block*pow_block*4);



int setBrick(int x, int y, int z, int value)
{
	//Проверка на то что такой элемент с такими координатами уже существует
	for (int i = 0; i < up_block; i ++)
	{
		if (*(buf + i*pow_block + 1) == x + (y << 10) + (z << 20))
		{
			printf("\n(%i  %i  %i)This item already exists \n",x,y,z);
			return -1;
		}
	}
	//Запись блока нового элемента
	*(buf + up_block*pow_block) = value;
	*(buf + up_block*pow_block + 1) = x + (y << 10) + (z << 20);//код координаты
	//Выделяю память на следующий элемент
	count_block++;
	up_block++;
	buf = (int*)realloc(buf, count_block*pow_block* 4);
	return 1;
}

//Описание основного массива
unsigned long int count_block = 0;//количество блоков в основном массиве с парами "значение(value)-код координаты" 
unsigned int pow_block = 2;//мощность одного блока основного массива
int* buf = (int*)malloc((count_block + 1)*pow_block * 4);//Основной массив. Какую-то память нужно сразу выделить, потому сразу выделяю

//Вспомогательный массив. В нём по возрастанию координат отсортированы блоки основного участка памяти buf
int* sorted_array = (int*)malloc((count_block + 1) * 4);//Какую-то память нужно сразу выделить, потому сразу выделяю


int setBrick(int x, int y, int z, int value)
{
	//Проверка на то что такой элемент с такими координатами уже существует
	for (int i = 0; i < count_block; i ++)
	{
		if (*(buf + i*pow_block + 1) == x + (y << 10) + (z << 20))
		{
			printf("\n(%i  %i  %i)This item already exists \n",x,y,z);
			return -1;
		}
	}//если совпаданий не найдёно, то функция продолжает работу
	
	//Выделение памяти на новый элемент
	count_block++;
	buf = (int*)realloc(buf, count_block*pow_block * 4);
	//Запись блока нового элемента в выделенную память
	*(buf + (count_block-1)*pow_block) = value;
	*(buf + (count_block-1)*pow_block + 1) = x + (y << 10) + (z << 20);//код координаты

	//Переиндексация вспомогательного массива sorted_array
	//Именование переменных ниже, а именно то что я придумал (хотя наверняка уже используют) назвать переменные в цикле r и l нравится мне настолько,
	//что я даже не вижу смысла делать тут комментарии. Код ниже очень красивый.
	sorted_array = (int*)realloc(sorted_array, count_block * 4);
	int r = count_block - 1;
	for (int l = 0; l < count_block-1; l++)
	{
		int num_block = *(sorted_array + l);
		if (*(buf + num_block*pow_block + 1)>x + (y << 10) + (z << 20))
		{
			for (; r > l; r--)
			{
				*(sorted_array + r) = *(sorted_array + r - 1);
			}
		}
	}
	*(sorted_array + r) = count_block - 1;

	return 1;
}

	//Переиндексация вспомогательного массива sorted_array
	//Именование переменных ниже, а именно то что я придумал (хотя наверняка уже используют) назвать переменные в цикле r и l нравится мне настолько,
	//что я даже не вижу смысла делать тут комментарии. Код ниже очень красивый.
	sorted_array = (int*)realloc(sorted_array, count_block * 4);
	int r = count_block - 1;
	for (int l = 0; l < count_block-1; l++)
	{
		int num_block = *(sorted_array + l);
		if (*(buf + num_block*pow_block + 1)>x + (y << 10) + (z << 20))
		{
			for (; r > l; r--)
			{
				*(sorted_array + r) = *(sorted_array + r - 1);
			}
		}
	}
	*(sorted_array + r) = count_block - 1;

int *p = *(buf + (count_block-1)*pow_block);
        *p = value;
        *(p+1) = x + (y << 10) + (z << 20);