void		array_fillbytes(char* arrayin, int arraylength, char bytevalue)
{
	if (!arrayin)					return;
	if (arraylength <= 0)		return;
	
	memset(arrayin, bytevalue, sizeof(char) * arraylength);
}


void		array_fillbytes(short* arrayin, int arraylength, short bytevalue)
{
	if (!arrayin)					return;
	if (arraylength <= 0)		return;
	
	memset(arrayin, (char)bytevalue, sizeof(short) * arraylength);
}

void	ShowArrayElements(int* inarray, int arraylength, var posx, var posy)
{
	if (!inarray) return;
	
	int i;
	for (i=0; i<arraylength; ++i)
		{
			draw_text( str_for_int(NULL, inarray[i]), posx, posy + i*20, COLOR_RED );
		}
}


void	ShowArrayElements(var* inarray, int arraylength, var posx, var posy)
{
	if (!inarray) return;
	
	int i;
	for (i=0; i<arraylength; ++i)
		{
			draw_text( str_for_num(NULL, inarray[i]), posx, posy + i*20, COLOR_GREEN );
		}
}

void		array_fill(char* arrayin, int arraylength, char elementvalue);										
void		array_fill(short* arrayin, int arraylength, short elementvalue);
void		array_fill(int* arrayin, int arraylength, int elementvalue);
void		array_fill(var* arrayin, int arraylength, var elementvalue);
void		array_fill(VECTOR* arrayin, int arraylength, VECTOR* elementvalue);

void array_fill(void *arrayin, int arraylength, char elementvaluem int elementSize);
{
	if(!arrayin || arraylength <= 0) 
		return;
	
	memset(arrayin, bytevalue, elementSize * arraylength);
}

//in lite-c i used such a similir function
void place_entity(ENTITY* my_ent,char* my_type)
{
	if(str_cmp(my_type,"a big rock"))
	{
	}
	if(str_cmp(my_type,"a small rock"))
	{
	}
	if(str_cmp(my_type,"a tree"))
	{
	}
}
...
place_entity(me,"a big rock");
place_entity(me,"a tree");

//in c++ i used this for a thread dispatcher ,same concept
void thread_dispatcher(const char* task,void* task_packet,void* second_task_packet)
{
	if(m_navbuilder)
	{
		if(strcmp(task,"build the navmesh")==0)
		{
			custombuild* build_settings=(custombuild*)task_packet;
			m_navbuilder->Nav_From_Custombuild(build_settings);
		}
		if(strcmp(task,"load the navmesh")==0)
		{
			char* filename=(char*)task_packet;
			m_navbuilder->load_all_tiles((char*)filename);
		}
		if(strcmp(task,"save the navmesh")==0)
		{
			char* filename=(char*)task_packet;
			m_navbuilder->save_all_tiles((char*)filename);
		}
		if(strcmp(task,"build all tiles")==0)
		{
			m_navbuilder->build_all_tiles();
		}
		if(strcmp(task,"add single tile")==0)
		{
			VECTOR* pos=(VECTOR*)task_packet;
			m_navbuilder->build_tile(pos);
		}
		if(strcmp(task,"build tiles in bounds")==0)
		{
			VECTOR* min=(VECTOR*)task_packet;
			VECTOR* max=(VECTOR*)second_task_packet;
			m_navbuilder->build_tiles_box(min,max);
		}
	}
}

//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////
//************************************
// BUILD A NAVMESH
//
DLLFUNC void* nav_build(custombuild* build_settings)
{
	thread_function *thread_func=new thread_function(thread_dispatcher,"build the navmesh",(custombuild*)build_settings,(int*)NULL);
	if(thread_func->is_alive()) return (thread_function *) thread_func;
	delete thread_func;
	return NULL;
}

void bla(char* type ,void* arg1,void* arg2,void* arg3)
{
	if(str_cmp(type,"a string"))
	{
		STRING* this_string=(STRING*)arg1;
		if(this_string)
		{
			...
		}
	}
	if(str_cmp(type,"an integer"))
	{
		int* this_integer=(int*)arg1;
		if(this_integer)
		{
			...
		}
	}
	if(str_cmp(type,"an integer with size"))
	{
		int* this_integer=(int*)arg1;
		int* this_size=(int*)arg2;
		if(this_integer && this_size>-1)
		{
			...
		}
	}
}

bla("a string",(STRING*)mystring,(int*)NULL,(int*)NULL);
//or
bla("a string",(STRING*)mystring,NULL,NULL);
bla("an integer",(int*)myinteger,......
bla("an integer with size",(int*)myinteger,(int*)my_size,NULL);

typedef struct
{
	void *_buffer; // Actual data
	size_t _size; // Number of elements
	size_t _capacity; // Allocated number of elements
	size_t _elementSize; // Element size
} array_t;

array_t *array_create(size_t elementSize)
{
	array_t *array = malloc(sizeof(array_t));
	array->_elementSize = elementSize;
	array->_size = 0;
	array->_capacity = 5; // start out with 5 elements. Tweak if desired. This just makes the life easier since there is always a buffer and we don't have to care about cases where it's NULL
	array->_buffer = malloc(array->_capacity * array->_elementSize);

	return array;
}
void array_delete(array_t *array)
{
	free(array->_buffer);
	free(array);
}

void __array_assert_size(array_t *array, size_t required) // Makes sure that the array fits
{
	size_t toCopy = array->_size;
	if(toCopy > size)
		toCopy = size;

	if(required > array->_capacity)
	{
		size_t nextCapacity = array->_capacity * 1.5; // Gives a nice grow curve. Alternatively doubling also works, gets messy with large arrays though
		if(nextCapacity < required)
			nextCapacity = required;

		void *buffer = malloc(nextCapacity * array->_elementSize); // TODO: Handle errors
		memcpy(buffer, array->_buffer, toCopy * array->_elementSize);
		free(array->_buffer);

		array->_buffer = buffer;
		array->_capacity = nextCapacity;
	}
	else
	{
		size_t nextCapacity = array->_capacity >> 1;
		if(nextCapacity >= required && nextCapacity > 5) // Keep at least space for 5 elements
		{
			void *buffer = malloc(nextCapacity * array->_elementSize); // TODO: Handle errors
			memcpy(buffer, array->_buffer, toCopy * array->_elementSize);
			free(array->_buffer);

			array->_buffer = buffer;
			array->_capacity = nextCapacity;
		}
	}
}


void array_copyin_data(array_t *array, void *data, size_t elements)
{
	__array_assert_size(array, array->_size + elements);
	memcpy(((char *)array->_buffer) + array->_size * array->_elementSize, data, elements * array->_elementSize);
	array->_size += elements;
}
void array_copyout_data(array_t *array, void *data, size_t start, size_t elements)
{
	if(start + elements >= array->_size)
	{
		printf("Trying to access elements [%d, %d) in array with only %d elements", start, start + elements, array->_size);
		return;
	}

	memcpy((data, (char *)array->_buffer) + start * array->_elementSize, elements * array->_elementSize);
}

// Alternatively, you can also work with single elements at a time... Something like this:
void array_add_object(array_t *array, void *object)
{
	__array_assert_size(array, array->_size + 1);
	memcpy(((char *)array->_buffer) + array->_size * array->_elementSize, data, array->_elementSize);
	array->_size ++;
}