result_t BinarySerializeNode::WriteToBuffer ( const void* _pData, uint _size )
{
//
uint originalSize = m_Capacity;
uint restSize = m_Capacity - m_CurPos;
ex_assert_return ( originalSize > 0, EResult::write_failed, "The size of the node can't be zero for writing." );
// if rest size less than the size we try to write, enlarge the size twice
while ( restSize < _size )
{
m_Capacity *= 2;
restSize = m_Capacity - m_CurPos;
}
// resize
if ( m_Capacity > originalSize )
{
m_pData = ex_realloc( m_pData, m_Capacity );
}
// copy the data to m_pData
memcpy ( (void*)((int8*)m_pData + m_CurPos), _pData, _size );
m_CurPos += _size;
return EResult::ok;
}
int main (void) {
int i = 0;
void *buffer[BUF_SIZE];
ex_sdk_init ();
i = 0;
while ( i < BUF_SIZE ) {
buffer[i] = ex_malloc( EX_MB(1) );
++i;
}
i = 0;
while ( i < BUF_SIZE ) {
buffer[i] = ex_realloc( buffer[i], EX_KB(1) * rand() % 2048 );
++i;
}
i = 0;
while ( i < BUF_SIZE ) {
ex_free(buffer[i]);
++i;
}
ex_sdk_deinit ();
return 0;
}
void spawn_tile_collision (Spawn *self, Tile *tile, Map *map) {
/* Kartenrand / unbegehbar */
if(self->x >= map->x || self->y >= map->y || !tile_can_walk(*tile)) {
/* umkehren */
switch(self->direction) {
case NORTH:
self->y++;
break;
case SOUTH:
self->y--;
break;
case EAST:
self->x--;
break;
case WEST:
self->x++;
break;
}
if (tile->type == TILE_TYPE_WALL) {
damage_spawn(self, 1, map);
push_msg("Kopf -> Wand (-1HP)", map);
}
}
else {
if (tile->number_of_items > 0) {
/* Items aufsammeln. */
self->inventory = ex_realloc(self->inventory, (self->inventory_size + tile->number_of_items) * sizeof(Item*));
for (unsigned int ii = 0; ii < tile->number_of_items; ++ii) {
if(tile->items[ii]->type != ITEM_TYPE_INVALID) {
self->inventory[++self->inventory_size - 1] = tile->items[ii];
}
}
/* Aufzählen, was aufgesammelt */
for(unsigned int i = 0; i < tile->number_of_items; ++i) {
if(tile->items[i]->type != ITEM_TYPE_INVALID) {
char* item_message = (char*)ex_calloc(22 + strlen(tile->items[i]->name), 1);
sprintf(item_message, "Du hast aufgenommen: %s", tile->items[i]->name);
push_msg(item_message, map);
free(item_message);
}
}
self->selected_item=self->inventory_size-1;
free(tile->items);
tile->items = NULL;
tile->number_of_items = 0;
}
/* Ausgang */
else if(tile->type == TILE_TYPE_EXIT) {
map->finished = 1;
}
}
}
/**
* Fügt einem Spawn damage Punkte Schaden zu, entfernt ihn von der Map
* und lässt seine Items fallen, falls es ihn tötet.
*/
void damage_spawn(Spawn *spawn, unsigned int damage, Map *map){
/*Sonderbahandlung für den Spieler*/
if(spawn->type==SPAWN_TYPE_PLAYER){
if(spawn->hp<=damage)
spawn->hp=0;
else
spawn->hp-=damage;
}
else{
/*wenns ihn tötet, entfernen*/
if (spawn->hp <= damage) {
Spawn **new_spawns = ex_calloc(map->number_of_spawns - 1, sizeof(Spawn *));
for (unsigned int ii = 0, jj = 0; ii < map->number_of_spawns; ++ii) {
if (map->spawns[ii] != spawn) {
new_spawns[jj++] = map->spawns[ii];
}
}
free(map->spawns);
map->spawns = new_spawns;
--map->number_of_spawns;
/* Items fallen lassen */
if(spawn->inventory_size > 0) {
unsigned int i, j, new_size;
Tile* died_here = &map->tiles[spawn->y * map->x + spawn->x];
new_size = died_here->number_of_items + spawn->inventory_size;
died_here->items = (Item**)ex_realloc(died_here->items, new_size * sizeof(Item*));
for(i = died_here->number_of_items, j = 0; i < new_size && j < spawn->inventory_size; ++i, ++j, ++died_here->number_of_items, --spawn->inventory_size) {
died_here->items[i] = spawn->inventory[j];
}
free(spawn->inventory);
spawn->inventory = NULL;
}
free_spawn(spawn);
}
else {
spawn->hp -= damage;
}
}
}
result_t BinarySerializeNode::loadFromFile ( const char* _fileName )
{
IFile::smart_ptr_t spFile = futil::file::readonly<PhysicalFile>(_fileName);
if ( spFile )
{
// read raw data
m_Capacity = uint(spFile->size());
m_CurPos = 0;
m_pData = ex_realloc ( m_pData, m_Capacity );
//
spFile->read ( m_pData, m_Capacity );
//
setLoading ();
}
else
{
return EResult::not_found;
}
return EResult::ok;
}
result_t BinarySerializeNode::loadFromFile ( IFile::smart_ptr_t _spFile, futil::sz_t _bytesToLoad )
{
if ( _spFile )
{
//
futil::sz_t restBytes = _spFile->sizeToEnd();
ex_assert_return ( _bytesToLoad <= restBytes, EResult::read_failed, "the rest bytes of the file is less than the bytes you try to read." );
// read raw data
m_Capacity = uint(_bytesToLoad);
m_CurPos = 0;
if ( m_Capacity > 0 )
{
m_pData = ex_realloc ( m_pData, m_Capacity );
_spFile->read ( m_pData, m_Capacity );
}
//
setLoading ();
}
return EResult::ok;
}
