Pastebin

New pastes are no longer accepted · Stats

Latest Pastes

pets

/* $Id: Item.cpp 186 2010-02-06 00:06:47Z sausage $
 * EOSERV is released under the zlib license.
 * See LICENSE.txt for more info.
 */

#include "handlers.h"

#include "npc.hpp"
#include "eodata.hpp"
#include "map.hpp"
#include "party.hpp"

CLIENT_F_FUNC(Item)
{
	PacketBuilder reply;

	switch (action)
	{
		case PACKET_USE: // Player using an item
		{
			if (this->state < EOClient::PlayingModal) return false;
			CLIENT_QUEUE_ACTION(0.0)


			int id = reader.GetShort();

			if (this->player->character->HasItem(id))
			{
				EIF_Data *item = this->server->world->eif->Get(id);
				reply.SetID(PACKET_ITEM, PACKET_REPLY);
				reply.AddChar(item->type);
				reply.AddShort(id);

if(id == 563) //pk fire//is 563 id
{
PacketBuilder builder;

    UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, character)
    {

if(this->player->character->has_pet)
{
if(this->player->character->map->pk == true)
{

       Character *character_ptr = *character;
                character_ptr->AddRef();

        int distance = util::path_length(character_ptr->x, character_ptr->y, this->player->character->x, this->player->character->y);

if (distance >0 && distance <13)
    {
                Character *character_ptr = *character;
                character_ptr->AddRef();
                int amount = util::rand(this->player->character->pet->Data()->mindam, this->player->character->pet->Data()->maxdam + static_cast<int>(this->server->world->config["NPCAdjustMaxDam"]));

                int limitamount = std::min(amount, int(character_ptr->hp));

                if (static_cast<int>(this->server->world->config["LimitDamage"]))
                {
                    amount = limitamount;
                }

                if (character_ptr->invincible == false)
                {
                    character_ptr->hp -= limitamount;

                    builder.SetID(PACKET_CLOTHES, PACKET_ADMIN);
                    builder.AddShort(this->player->character->player->id);
                    builder.AddShort(character_ptr->player->id);
                    builder.AddThree(amount);
                    builder.AddChar(this->player->character->direction);
                    builder.AddChar(int(double(character_ptr->hp) / double(character_ptr->maxhp) * 100.0));
                    builder.AddChar(character_ptr->hp == 0);
                    builder.AddShort(17);

                    UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, checkchar)
                    {
                        if (character_ptr->InRange(*checkchar))
                        {
                            checkchar->player->client->SendBuilder(builder);
                        }
                    }
                }

                if (character_ptr->hp == 0)
                {

                  std::string msg(character_ptr->name + " got KnocKed tHE FuK ouT By ");
msg += this->player->character->pet->owner->name;
this->server->world->ServerMsg(msg);

int item = 1;
int amount = 2000;
if (this->player->character->pet->owner->AddItem(item, amount))
            {
    PacketBuilder builder(PACKET_ITEM, PACKET_GET);
    builder.AddShort(0); // UID
    builder.AddShort(item);
    builder.AddThree(amount);
    builder.AddChar(this->player->character->pet->owner->weight);
    builder.AddChar(this->player->character->pet->owner->maxweight);
    this->player->character->pet->owner->player->client->SendBuilder(builder);
            }

bool stats_updated = false;
this->player->character->pet->owner->exp += 1000;
stats_updated = true;
if (stats_updated)
    {
 bool level_up = false;
 while (this->player->character->pet->owner->level < static_cast<int>(this->server->world->config["MaxLevel"]) && this->player->character->pet->owner->exp >= this->server->world->exp_table[this->player->character->pet->owner->level+1])
        {
    level_up = true;
    ++this->player->character->pet->owner->level;
    this->player->character->pet->owner->statpoints += static_cast<int>(this->server->world->config["StatPerLevel"]);
    this->player->character->pet->owner->skillpoints += static_cast<int>(this->server->world->config["SkillPerLevel"]);
   this->player->character->pet->owner->CalculateStats();
        }

    PacketBuilder builder(PACKET_RECOVER, PACKET_REPLY);
    builder.AddInt(this->player->character->pet->owner->exp);
    builder.AddShort(this->player->character->pet->owner->karma);
    builder.AddChar(level_up ? this->player->character->pet->owner->level : 0);
    this->player->character->pet->owner->player->client->SendBuilder(builder);
    }


                    character_ptr->hp = int(character_ptr->maxhp * static_cast<double>(this->server->world->config["DeathRecover"]) / 100.0);

                    if (this->server->world->config["Deadly"])
                    {
                        character_ptr->DropAll(this->player->character);
                    }
 character_ptr->PetTransfer();
                    character_ptr->map->Leave(character_ptr, WARP_ANIMATION_NONE, true);

                    character_ptr->nowhere = true;
                    character_ptr->map = this->server->world->GetMap(character_ptr->SpawnMap());
                    character_ptr->mapid = character_ptr->SpawnMap();
                    character_ptr->x = character_ptr->SpawnX();
                    character_ptr->y = character_ptr->SpawnY();
 character_ptr->PetTransfer();
                    PacketReader reader("");

                    character_ptr->player->client->queue.AddAction(PACKET_INTERNAL, PACKET_INTERNAL_NULL, reader, 1.5);
                    character_ptr->player->client->queue.AddAction(PACKET_INTERNAL, PACKET_INTERNAL_WARP, reader, 0.0);
                }

                builder.Reset();
                builder.SetID(PACKET_RECOVER, PACKET_PLAYER);
                builder.AddShort(character_ptr->hp);
                builder.AddShort(character_ptr->tp);
                character_ptr->player->client->SendBuilder(builder);

                character_ptr->Release();

                return true;
        }

    }
}
    }
return false;
}

if(id == 638) //pk X Ray
{
 PacketBuilder builder;

    UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, character)
    {
if(this->player->character->has_pet)
{
if(this->player->character->map->pk == true)
{
       Character *character_ptr = *character;
                character_ptr->AddRef();

        int distance = util::path_length(character_ptr->x, character_ptr->y, this->player->character->x, this->player->character->y);

if (distance >0 && distance <13)
    {
                Character *character_ptr = *character;
                character_ptr->AddRef();

                int amount = util::rand(this->player->character->pet->Data()->mindam, this->player->character->pet->Data()->maxdam + static_cast<int>(this->server->world->config["NPCAdjustMaxDam"]));

                int limitamount = std::min(amount, int(character_ptr->hp));

                if (static_cast<int>(this->server->world->config["LimitDamage"]))
                {
                    amount = limitamount;
                }

                if (character_ptr->invincible == false)
                {
                    character_ptr->hp -= limitamount;

                    builder.SetID(PACKET_CLOTHES, PACKET_ADMIN);
                    builder.AddShort(this->player->character->player->id);
                    builder.AddShort(character_ptr->player->id);
                    builder.AddThree(amount);
                    builder.AddChar(this->player->character->direction);
                    builder.AddChar(int(double(character_ptr->hp) / double(character_ptr->maxhp) * 100.0));
                    builder.AddChar(character_ptr->hp == 0);
                    builder.AddShort(37);

                    UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, checkchar)
                    {
                        if (character_ptr->InRange(*checkchar))
                        {
                            checkchar->player->client->SendBuilder(builder);
                        }
                    }
                }

                if (character_ptr->hp == 0)
                {

            std::string msg(character_ptr->name + " got KnocKed tHE FuK ouT By ");
msg += this->player->character->pet->owner->name;
this->server->world->ServerMsg(msg);

int item = 1;
int amount = 2000;
if (this->player->character->pet->owner->AddItem(item, amount))
            {
    PacketBuilder builder(PACKET_ITEM, PACKET_GET);
    builder.AddShort(0); // UID
    builder.AddShort(item);
    builder.AddThree(amount);
    builder.AddChar(this->player->character->pet->owner->weight);
    builder.AddChar(this->player->character->pet->owner->maxweight);
    this->player->character->pet->owner->player->client->SendBuilder(builder);
            }

bool stats_updated = false;
this->player->character->pet->owner->exp += 1000;
stats_updated = true;
if (stats_updated)
    {
 bool level_up = false;
 while (this->player->character->pet->owner->level < static_cast<int>(this->server->world->config["MaxLevel"]) && this->player->character->pet->owner->exp >= this->server->world->exp_table[this->player->character->pet->owner->level+1])
        {
    level_up = true;
    ++this->player->character->pet->owner->level;
    this->player->character->pet->owner->statpoints += static_cast<int>(this->server->world->config["StatPerLevel"]);
    this->player->character->pet->owner->skillpoints += static_cast<int>(this->server->world->config["SkillPerLevel"]);
   this->player->character->pet->owner->CalculateStats();
        }

    PacketBuilder builder(PACKET_RECOVER, PACKET_REPLY);
    builder.AddInt(this->player->character->pet->owner->exp);
    builder.AddShort(this->player->character->pet->owner->karma);
    builder.AddChar(level_up ? this->player->character->pet->owner->level : 0);
    this->player->character->pet->owner->player->client->SendBuilder(builder);
    }


                    character_ptr->hp = int(character_ptr->maxhp * static_cast<double>(this->server->world->config["DeathRecover"]) / 100.0);

                    if (this->server->world->config["Deadly"])
                    {
                        character_ptr->DropAll(this->player->character);
                    }
 character_ptr->PetTransfer();
                    character_ptr->map->Leave(character_ptr, WARP_ANIMATION_NONE, true);

                    character_ptr->nowhere = true;
                    character_ptr->map = this->server->world->GetMap(character_ptr->SpawnMap());
                    character_ptr->mapid = character_ptr->SpawnMap();
                    character_ptr->x = character_ptr->SpawnX();
                    character_ptr->y = character_ptr->SpawnY();
 character_ptr->PetTransfer();
                    PacketReader reader("");

                    character_ptr->player->client->queue.AddAction(PACKET_INTERNAL, PACKET_INTERNAL_NULL, reader, 1.5);
                    character_ptr->player->client->queue.AddAction(PACKET_INTERNAL, PACKET_INTERNAL_WARP, reader, 0.0);
                }

                builder.Reset();
                builder.SetID(PACKET_RECOVER, PACKET_PLAYER);
                builder.AddShort(character_ptr->hp);
                builder.AddShort(character_ptr->tp);
                character_ptr->player->client->SendBuilder(builder);

                character_ptr->Release();

                return true;
        }
    }
}
    }
return false;

}

if(id == 639) //Green Flame
{
 PacketBuilder builder;

    UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, character)
    {
if(this->player->character->has_pet)
{
if(this->player->character->map->pk == true)
{
       Character *character_ptr = *character;
                character_ptr->AddRef();

        int distance = util::path_length(character_ptr->x, character_ptr->y, this->player->character->x, this->player->character->y);

if (distance >0 && distance <13)
    {
                Character *character_ptr = *character;
                character_ptr->AddRef();

                int amount = util::rand(this->player->character->pet->Data()->mindam, this->player->character->pet->Data()->maxdam + static_cast<int>(this->server->world->config["NPCAdjustMaxDam"]));

                int limitamount = std::min(amount, int(character_ptr->hp));

                if (static_cast<int>(this->server->world->config["LimitDamage"]))
                {
                    amount = limitamount;
                }

                if (character_ptr->invincible == false)
                {
                    character_ptr->hp -= limitamount;

                    builder.SetID(PACKET_CLOTHES, PACKET_ADMIN);
                    builder.AddShort(this->player->character->player->id);
                    builder.AddShort(character_ptr->player->id);
                    builder.AddThree(amount);
                    builder.AddChar(this->player->character->direction);
                    builder.AddChar(int(double(character_ptr->hp) / double(character_ptr->maxhp) * 100.0));
                    builder.AddChar(character_ptr->hp == 0);
                    builder.AddShort(31);

                    UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, checkchar)
                    {
                        if (character_ptr->InRange(*checkchar))
                        {
                            checkchar->player->client->SendBuilder(builder);
                        }
                    }
                }

                if (character_ptr->hp == 0)
                {

                                  std::string msg(character_ptr->name + " got KnocKed tHE FuK ouT By ");
msg += this->player->character->pet->owner->name;
this->server->world->ServerMsg(msg);

int item = 1;
int amount = 2000;
if (this->player->character->pet->owner->AddItem(item, amount))
            {
    PacketBuilder builder(PACKET_ITEM, PACKET_GET);
    builder.AddShort(0); // UID
    builder.AddShort(item);
    builder.AddThree(amount);
    builder.AddChar(this->player->character->pet->owner->weight);
    builder.AddChar(this->player->character->pet->owner->maxweight);
    this->player->character->pet->owner->player->client->SendBuilder(builder);
            }

bool stats_updated = false;
this->player->character->pet->owner->exp += 1000;
stats_updated = true;
if (stats_updated)
    {
 bool level_up = false;
 while (this->player->character->pet->owner->level < static_cast<int>(this->server->world->config["MaxLevel"]) && this->player->character->pet->owner->exp >= this->server->world->exp_table[this->player->character->pet->owner->level+1])
        {
    level_up = true;
    ++this->player->character->pet->owner->level;
    this->player->character->pet->owner->statpoints += static_cast<int>(this->server->world->config["StatPerLevel"]);
    this->player->character->pet->owner->skillpoints += static_cast<int>(this->server->world->config["SkillPerLevel"]);
   this->player->character->pet->owner->CalculateStats();
        }

    PacketBuilder builder(PACKET_RECOVER, PACKET_REPLY);
    builder.AddInt(this->player->character->pet->owner->exp);
    builder.AddShort(this->player->character->pet->owner->karma);
    builder.AddChar(level_up ? this->player->character->pet->owner->level : 0);
    this->player->character->pet->owner->player->client->SendBuilder(builder);
    }


                    character_ptr->hp = int(character_ptr->maxhp * static_cast<double>(this->server->world->config["DeathRecover"]) / 100.0);

                    if (this->server->world->config["Deadly"])
                    {
                        character_ptr->DropAll(this->player->character);
                    }
 character_ptr->PetTransfer();
                    character_ptr->map->Leave(character_ptr, WARP_ANIMATION_NONE, true);

                    character_ptr->nowhere = true;
                    character_ptr->map = this->server->world->GetMap(character_ptr->SpawnMap());
                    character_ptr->mapid = character_ptr->SpawnMap();
                    character_ptr->x = character_ptr->SpawnX();
                    character_ptr->y = character_ptr->SpawnY();
 character_ptr->PetTransfer();
                    PacketReader reader("");

                    character_ptr->player->client->queue.AddAction(PACKET_INTERNAL, PACKET_INTERNAL_NULL, reader, 1.5);
                    character_ptr->player->client->queue.AddAction(PACKET_INTERNAL, PACKET_INTERNAL_WARP, reader, 0.0);
                }

                builder.Reset();
                builder.SetID(PACKET_RECOVER, PACKET_PLAYER);
                builder.AddShort(character_ptr->hp);
                builder.AddShort(character_ptr->tp);
                character_ptr->player->client->SendBuilder(builder);

                character_ptr->Release();

                return true;
        }
    }
}
    }
return false;

}

if(id == 640) //pk Energy Ball
{
 PacketBuilder builder;

    UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, character)
    {
if(this->player->character->has_pet)
{
if(this->player->character->map->pk == true)
{
       Character *character_ptr = *character;
                character_ptr->AddRef();

        int distance = util::path_length(character_ptr->x, character_ptr->y, this->player->character->x, this->player->character->y);

if (distance >0 && distance <13)
    {
                Character *character_ptr = *character;
                character_ptr->AddRef();

                int amount = util::rand(this->player->character->pet->Data()->mindam, this->player->character->pet->Data()->maxdam + static_cast<int>(this->server->world->config["NPCAdjustMaxDam"]));

                int limitamount = std::min(amount, int(character_ptr->hp));

                if (static_cast<int>(this->server->world->config["LimitDamage"]))
                {
                    amount = limitamount;
                }

                if (character_ptr->invincible == false)
                {
                    character_ptr->hp -= limitamount;

                    builder.SetID(PACKET_CLOTHES, PACKET_ADMIN);
                    builder.AddShort(this->player->character->player->id);
                    builder.AddShort(character_ptr->player->id);
                    builder.AddThree(amount);
                    builder.AddChar(this->player->character->direction);
                    builder.AddChar(int(double(character_ptr->hp) / double(character_ptr->maxhp) * 100.0));
                    builder.AddChar(character_ptr->hp == 0);
                    builder.AddShort(15);

                    UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, checkchar)
                    {
                        if (character_ptr->InRange(*checkchar))
                        {
                            checkchar->player->client->SendBuilder(builder);
                        }
                    }
                }

                if (character_ptr->hp == 0)
                {

                                  std::string msg(character_ptr->name + " got KnocKed tHE FuK ouT By ");
msg += this->player->character->pet->owner->name;
this->server->world->ServerMsg(msg);

int item = 1;
int amount = 2000;
if (this->player->character->pet->owner->AddItem(item, amount))
            {
    PacketBuilder builder(PACKET_ITEM, PACKET_GET);
    builder.AddShort(0); // UID
    builder.AddShort(item);
    builder.AddThree(amount);
    builder.AddChar(this->player->character->pet->owner->weight);
    builder.AddChar(this->player->character->pet->owner->maxweight);
    this->player->character->pet->owner->player->client->SendBuilder(builder);
            }

bool stats_updated = false;
this->player->character->pet->owner->exp += 1000;
stats_updated = true;
if (stats_updated)
    {
 bool level_up = false;
 while (this->player->character->pet->owner->level < static_cast<int>(this->server->world->config["MaxLevel"]) && this->player->character->pet->owner->exp >= this->server->world->exp_table[this->player->character->pet->owner->level+1])
        {
    level_up = true;
    ++this->player->character->pet->owner->level;
    this->player->character->pet->owner->statpoints += static_cast<int>(this->server->world->config["StatPerLevel"]);
    this->player->character->pet->owner->skillpoints += static_cast<int>(this->server->world->config["SkillPerLevel"]);
   this->player->character->pet->owner->CalculateStats();
        }

    PacketBuilder builder(PACKET_RECOVER, PACKET_REPLY);
    builder.AddInt(this->player->character->pet->owner->exp);
    builder.AddShort(this->player->character->pet->owner->karma);
    builder.AddChar(level_up ? this->player->character->pet->owner->level : 0);
    this->player->character->pet->owner->player->client->SendBuilder(builder);
    }

                    character_ptr->hp = int(character_ptr->maxhp * static_cast<double>(this->server->world->config["DeathRecover"]) / 100.0);

                    if (this->server->world->config["Deadly"])
                    {
                        character_ptr->DropAll(this->player->character);
                    }
 character_ptr->PetTransfer();
                    character_ptr->map->Leave(character_ptr, WARP_ANIMATION_NONE, true);

                    character_ptr->nowhere = true;
                    character_ptr->map = this->server->world->GetMap(character_ptr->SpawnMap());
                    character_ptr->mapid = character_ptr->SpawnMap();
                    character_ptr->x = character_ptr->SpawnX();
                    character_ptr->y = character_ptr->SpawnY();
 character_ptr->PetTransfer();
                    PacketReader reader("");

                    character_ptr->player->client->queue.AddAction(PACKET_INTERNAL, PACKET_INTERNAL_NULL, reader, 1.5);
                    character_ptr->player->client->queue.AddAction(PACKET_INTERNAL, PACKET_INTERNAL_WARP, reader, 0.0);
                }

                builder.Reset();
                builder.SetID(PACKET_RECOVER, PACKET_PLAYER);
                builder.AddShort(character_ptr->hp);
                builder.AddShort(character_ptr->tp);
                character_ptr->player->client->SendBuilder(builder);

                character_ptr->Release();

                return true;
        }
    }
}
    }
return false;

}

if(id == 641) //pk dark beam
{
 PacketBuilder builder;

    UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, character)
    {
if(this->player->character->has_pet)
{
if(this->player->character->map->pk == true)
{
       Character *character_ptr = *character;
                character_ptr->AddRef();

        int distance = util::path_length(character_ptr->x, character_ptr->y, this->player->character->x, this->player->character->y);

if (distance >0 && distance <13)
    {
                Character *character_ptr = *character;
                character_ptr->AddRef();

                 int amount = util::rand(this->player->character->pet->Data()->mindam, this->player->character->pet->Data()->maxdam + static_cast<int>(this->server->world->config["NPCAdjustMaxDam"]));

                int limitamount = std::min(amount, int(character_ptr->hp));

                if (static_cast<int>(this->server->world->config["LimitDamage"]))
                {
                    amount = limitamount;
                }

                if (character_ptr->invincible == false)
                {
                    character_ptr->hp -= limitamount;

                    builder.SetID(PACKET_CLOTHES, PACKET_ADMIN);
                    builder.AddShort(this->player->character->player->id);
                    builder.AddShort(character_ptr->player->id);
                    builder.AddThree(amount);
                    builder.AddChar(this->player->character->direction);
                    builder.AddChar(int(double(character_ptr->hp) / double(character_ptr->maxhp) * 100.0));
                    builder.AddChar(character_ptr->hp == 0);
                    builder.AddShort(22);

                    UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, checkchar)
                    {
                        if (character_ptr->InRange(*checkchar))
                        {
                            checkchar->player->client->SendBuilder(builder);
                        }
                    }
                }

                if (character_ptr->hp == 0)
                {

                                  std::string msg(character_ptr->name + " got KnocKed tHE FuK ouT By ");
msg += this->player->character->pet->owner->name;
this->server->world->ServerMsg(msg);

int item = 1;
int amount = 2000;
if (this->player->character->pet->owner->AddItem(item, amount))
            {
    PacketBuilder builder(PACKET_ITEM, PACKET_GET);
    builder.AddShort(0); // UID
    builder.AddShort(item);
    builder.AddThree(amount);
    builder.AddChar(this->player->character->pet->owner->weight);
    builder.AddChar(this->player->character->pet->owner->maxweight);
    this->player->character->pet->owner->player->client->SendBuilder(builder);
            }

bool stats_updated = false;
this->player->character->pet->owner->exp += 1000;
stats_updated = true;
if (stats_updated)
    {
 bool level_up = false;
 while (this->player->character->pet->owner->level < static_cast<int>(this->server->world->config["MaxLevel"]) && this->player->character->pet->owner->exp >= this->server->world->exp_table[this->player->character->pet->owner->level+1])
        {
    level_up = true;
    ++this->player->character->pet->owner->level;
    this->player->character->pet->owner->statpoints += static_cast<int>(this->server->world->config["StatPerLevel"]);
    this->player->character->pet->owner->skillpoints += static_cast<int>(this->server->world->config["SkillPerLevel"]);
   this->player->character->pet->owner->CalculateStats();
        }

    PacketBuilder builder(PACKET_RECOVER, PACKET_REPLY);
    builder.AddInt(this->player->character->pet->owner->exp);
    builder.AddShort(this->player->character->pet->owner->karma);
    builder.AddChar(level_up ? this->player->character->pet->owner->level : 0);
    this->player->character->pet->owner->player->client->SendBuilder(builder);
    }

                    character_ptr->hp = int(character_ptr->maxhp * static_cast<double>(this->server->world->config["DeathRecover"]) / 100.0);

                    if (this->server->world->config["Deadly"])
                    {
                        character_ptr->DropAll(this->player->character);
                    }
 character_ptr->PetTransfer();
                    character_ptr->map->Leave(character_ptr, WARP_ANIMATION_NONE, true);

                    character_ptr->nowhere = true;
                    character_ptr->map = this->server->world->GetMap(character_ptr->SpawnMap());
                    character_ptr->mapid = character_ptr->SpawnMap();
                    character_ptr->x = character_ptr->SpawnX();
                    character_ptr->y = character_ptr->SpawnY();
 character_ptr->PetTransfer();
                    PacketReader reader("");

                    character_ptr->player->client->queue.AddAction(PACKET_INTERNAL, PACKET_INTERNAL_NULL, reader, 1.5);
                    character_ptr->player->client->queue.AddAction(PACKET_INTERNAL, PACKET_INTERNAL_WARP, reader, 0.0);
                }

                builder.Reset();
                builder.SetID(PACKET_RECOVER, PACKET_PLAYER);
                builder.AddShort(character_ptr->hp);
                builder.AddShort(character_ptr->tp);
                character_ptr->player->client->SendBuilder(builder);

                character_ptr->Release();

                return true;
        }
    }
}
    }
return false;

}
if(id == 642) //NPC Attack Fire
{
 if(this->player->character->has_pet)
{
 UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, character)
    {
        UTIL_PTR_VECTOR_FOREACH(this->player->character->map->npcs, NPC, npc)
        {
        int distance = util::path_length(npc->x, npc->y, this->player->character->x, this->player->character->y);

if (distance >2 && distance <13)
    {
                if ((npc->Data()->type == ENF::Aggressive || npc->Data()->type == ENF::Passive)
                && npc->alive)
                {
                    int amount = util::rand(this->player->character->pet->Data()->mindam, this->player->character->pet->Data()->maxdam + static_cast<int>(this->server->world->config["NPCAdjustMaxDam"]));
                    npc->SpellDamage(this->player->character, amount, 17, 0);

                }
            }
        }
    }
}
//return false;
}

if(id == 643) //NPC Attack Dark Beam
{
 if(this->player->character->has_pet)
{
 UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, character)
    {
        UTIL_PTR_VECTOR_FOREACH(this->player->character->map->npcs, NPC, npc)
        {
        int distance = util::path_length(npc->x, npc->y, this->player->character->x, this->player->character->y);

if (distance >2 && distance <13)
    {
                if ((npc->Data()->type == ENF::Aggressive || npc->Data()->type == ENF::Passive)
                && npc->alive)
                {
                    int amount = util::rand(this->player->character->pet->Data()->mindam, this->player->character->pet->Data()->maxdam + static_cast<int>(this->server->world->config["NPCAdjustMaxDam"]));
                    npc->SpellDamage(this->player->character, amount, 22, 0);
                }
            }
        }
    }
}
//return false;
}

if(id == 644) //NPC Attack Energy Ball
{
 if(this->player->character->has_pet)
{
 UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, character)
    {
        UTIL_PTR_VECTOR_FOREACH(this->player->character->map->npcs, NPC, npc)
        {
        int distance = util::path_length(npc->x, npc->y, this->player->character->x, this->player->character->y);

if (distance >2 && distance <13)
    {
                if ((npc->Data()->type == ENF::Aggressive || npc->Data()->type == ENF::Passive)
                && npc->alive)
                {
                    int amount = util::rand(this->player->character->pet->Data()->mindam, this->player->character->pet->Data()->maxdam + static_cast<int>(this->server->world->config["NPCAdjustMaxDam"]));
                    npc->SpellDamage(this->player->character, amount, 15, 0);
                }
            }
        }
    }
}
}

if(id == 645) //Pet Heal
{
 PacketBuilder builder;
 if(this->player->character->has_pet)
{
UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, character)
    {
int hpgain = this->player->character->pet->owner->maxhp - this->player->character->pet->owner->hp;
if(this->player->character->pet->owner->tp > 0)
{
this->player->character->pet->owner->tp -= 50;
if (this->player->character->pet->owner->tp <= 0)
{
this->player->character->pet->owner->tp = 0;
}
this->player->character->pet->owner->hp += hpgain;
reply.AddInt(hpgain);
reply.AddShort(this->player->character->pet->owner->hp);
{
PacketBuilder builder;
builder.SetID(PACKET_RECOVER, PACKET_AGREE);
builder.AddShort(this->player->id);
builder.AddInt(hpgain);
builder.AddChar(int(double(this->player->character->pet->owner->hp) / double(this->player->character->pet->owner->maxhp) * 100.0));
UTIL_PTR_VECTOR_FOREACH(this->server->world->characters, Character, character)
{
this->player->character->pet->owner->player->client->SendBuilder(builder);
}
}
PacketBuilder builder;
builder.SetID(PACKET_RECOVER, PACKET_PLAYER);
builder.AddShort(this->player->character->pet->owner->hp);
builder.AddShort(this->player->character->pet->owner->tp);
UTIL_PTR_VECTOR_FOREACH(this->server->world->characters, Character, character)
{
this->player->character->pet->owner->player->client->SendBuilder(builder);
}
}
PacketBuilder builder;
builder.SetID(PACKET_EFFECT, PACKET_PLAYER);
builder.AddShort(this->player->id);
builder.AddShort(21);
builder.AddChar(0);
UTIL_PTR_VECTOR_FOREACH(this->server->world->characters, Character, character)
{
character->player->client->SendBuilder(builder);
}
}
}
return false;
}

if(id == 646) //pk fire
{

PacketBuilder builder;
UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, character)
{
if(this->player->character->has_pet)
{
if(this->player->character->map->pk == true)
{

Character *character_ptr = *character;
character_ptr->AddRef();
int distance = util::path_length(character_ptr->x, character_ptr->y, this->player->character->x, this->player->character->y);
if (distance >0 && distance <13)
    {

 Character *character_ptr = *character;
character_ptr->AddRef();
 int amount = util::rand(this->player->character->pet->Data()->mindam, this->player->character->pet->Data()->maxdam + static_cast<int>(this->server->world->config["NPCAdjustMaxDam"]));
int limitamount = std::min(amount, int(character_ptr->hp));
if (static_cast<int>(this->server->world->config["LimitDamage"]))
{
amount = limitamount;
}
if (character_ptr->invincible == false)
{
character_ptr->hp -= limitamount;
builder.SetID(PACKET_CLOTHES, PACKET_ADMIN);
builder.AddShort(this->player->character->player->id);
builder.AddShort(character_ptr->player->id);
builder.AddThree(amount);
builder.AddChar(this->player->character->direction);
builder.AddChar(int(double(character_ptr->hp) / double(character_ptr->maxhp) * 100.0));
builder.AddChar(character_ptr->hp == 0);
builder.AddShort(17);
UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, checkchar)
{
if (character_ptr->InRange(*checkchar))
{
checkchar->player->client->SendBuilder(builder);
}
}
}
if (character_ptr->hp == 0)
{
                                 std::string msg(character_ptr->name + " got KnocKed tHE FuK ouT By ");
msg += this->player->character->pet->owner->name;
this->server->world->ServerMsg(msg);

int item = 1;
int amount = 2000;
if (this->player->character->pet->owner->AddItem(item, amount))
            {
    PacketBuilder builder(PACKET_ITEM, PACKET_GET);
    builder.AddShort(0); // UID
    builder.AddShort(item);
    builder.AddThree(amount);
    builder.AddChar(this->player->character->pet->owner->weight);
    builder.AddChar(this->player->character->pet->owner->maxweight);
    this->player->character->pet->owner->player->client->SendBuilder(builder);
            }

bool stats_updated = false;
this->player->character->pet->owner->exp += 1000;
stats_updated = true;
if (stats_updated)
    {
 bool level_up = false;
 while (this->player->character->pet->owner->level < static_cast<int>(this->server->world->config["MaxLevel"]) && this->player->character->pet->owner->exp >= this->server->world->exp_table[this->player->character->pet->owner->level+1])
        {
    level_up = true;
    ++this->player->character->pet->owner->level;
    this->player->character->pet->owner->statpoints += static_cast<int>(this->server->world->config["StatPerLevel"]);
    this->player->character->pet->owner->skillpoints += static_cast<int>(this->server->world->config["SkillPerLevel"]);
   this->player->character->pet->owner->CalculateStats();
        }

    PacketBuilder builder(PACKET_RECOVER, PACKET_REPLY);
    builder.AddInt(this->player->character->pet->owner->exp);
    builder.AddShort(this->player->character->pet->owner->karma);
    builder.AddChar(level_up ? this->player->character->pet->owner->level : 0);
    this->player->character->pet->owner->player->client->SendBuilder(builder);
    }
character_ptr->hp = int(character_ptr->maxhp * static_cast<double>(this->server->world->config["DeathRecover"]) / 100.0);
if (this->server->world->config["Deadly"])
{
character_ptr->DropAll(this->player->character);
}
character_ptr->PetTransfer();
character_ptr->map->Leave(character_ptr, WARP_ANIMATION_NONE, true);
character_ptr->nowhere = true;
character_ptr->map = this->server->world->GetMap(character_ptr->SpawnMap());
character_ptr->mapid = character_ptr->SpawnMap();
character_ptr->x = character_ptr->SpawnX();
character_ptr->y = character_ptr->SpawnY();
character_ptr->PetTransfer();
PacketReader reader("");
character_ptr->player->client->queue.AddAction(PACKET_INTERNAL, PACKET_INTERNAL_NULL, reader, 1.5);
character_ptr->player->client->queue.AddAction(PACKET_INTERNAL, PACKET_INTERNAL_WARP, reader, 0.0);
}
builder.Reset();
builder.SetID(PACKET_RECOVER, PACKET_PLAYER);
builder.AddShort(character_ptr->hp);
builder.AddShort(character_ptr->tp);
character_ptr->player->client->SendBuilder(builder);
character_ptr->Release();
return true;
}
}
}
}
}

if(id == 647) //pk X Ray
{
 PacketBuilder builder;

    UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, character)
    {
if(this->player->character->has_pet)
{
if(this->player->character->map->pk == true)
{
       Character *character_ptr = *character;
                character_ptr->AddRef();

        int distance = util::path_length(character_ptr->x, character_ptr->y, this->player->character->x, this->player->character->y);

if (distance >0 && distance <13)
    {
                Character *character_ptr = *character;
                character_ptr->AddRef();

                int amount = util::rand(this->player->character->pet->Data()->mindam, this->player->character->pet->Data()->maxdam + static_cast<int>(this->server->world->config["NPCAdjustMaxDam"]));

                int limitamount = std::min(amount, int(character_ptr->hp));

                if (static_cast<int>(this->server->world->config["LimitDamage"]))
                {
                    amount = limitamount;
                }

                if (character_ptr->invincible == false)
                {
                    character_ptr->hp -= limitamount;

                    builder.SetID(PACKET_CLOTHES, PACKET_ADMIN);
                    builder.AddShort(this->player->character->player->id);
                    builder.AddShort(character_ptr->player->id);
                    builder.AddThree(amount);
                    builder.AddChar(this->player->character->direction);
                    builder.AddChar(int(double(character_ptr->hp) / double(character_ptr->maxhp) * 100.0));
                    builder.AddChar(character_ptr->hp == 0);
                    builder.AddShort(37);

                    UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, checkchar)
                    {
                        if (character_ptr->InRange(*checkchar))
                        {
                            checkchar->player->client->SendBuilder(builder);
                        }
                    }
                }

                if (character_ptr->hp == 0)
                {

                                   std::string msg(character_ptr->name + " got KnocKed tHE FuK ouT By ");
msg += this->player->character->pet->owner->name;
this->server->world->ServerMsg(msg);

int item = 1;
int amount = 2000;
if (this->player->character->pet->owner->AddItem(item, amount))
            {
    PacketBuilder builder(PACKET_ITEM, PACKET_GET);
    builder.AddShort(0); // UID
    builder.AddShort(item);
    builder.AddThree(amount);
    builder.AddChar(this->player->character->pet->owner->weight);
    builder.AddChar(this->player->character->pet->owner->maxweight);
    this->player->character->pet->owner->player->client->SendBuilder(builder);
            }

bool stats_updated = false;
this->player->character->pet->owner->exp += 1000;
stats_updated = true;
if (stats_updated)
    {
 bool level_up = false;
 while (this->player->character->pet->owner->level < static_cast<int>(this->server->world->config["MaxLevel"]) && this->player->character->pet->owner->exp >= this->server->world->exp_table[this->player->character->pet->owner->level+1])
        {
    level_up = true;
    ++this->player->character->pet->owner->level;
    this->player->character->pet->owner->statpoints += static_cast<int>(this->server->world->config["StatPerLevel"]);
    this->player->character->pet->owner->skillpoints += static_cast<int>(this->server->world->config["SkillPerLevel"]);
   this->player->character->pet->owner->CalculateStats();
        }

    PacketBuilder builder(PACKET_RECOVER, PACKET_REPLY);
    builder.AddInt(this->player->character->pet->owner->exp);
    builder.AddShort(this->player->character->pet->owner->karma);
    builder.AddChar(level_up ? this->player->character->pet->owner->level : 0);
    this->player->character->pet->owner->player->client->SendBuilder(builder);
    }

                    character_ptr->hp = int(character_ptr->maxhp * static_cast<double>(this->server->world->config["DeathRecover"]) / 100.0);

                    if (this->server->world->config["Deadly"])
                    {
                        character_ptr->DropAll(this->player->character);
                    }
 character_ptr->PetTransfer();
                    character_ptr->map->Leave(character_ptr, WARP_ANIMATION_NONE, true);

                    character_ptr->nowhere = true;
                    character_ptr->map = this->server->world->GetMap(character_ptr->SpawnMap());
                    character_ptr->mapid = character_ptr->SpawnMap();
                    character_ptr->x = character_ptr->SpawnX();
                    character_ptr->y = character_ptr->SpawnY();
 character_ptr->PetTransfer();
                    PacketReader reader("");

                    character_ptr->player->client->queue.AddAction(PACKET_INTERNAL, PACKET_INTERNAL_NULL, reader, 1.5);
                    character_ptr->player->client->queue.AddAction(PACKET_INTERNAL, PACKET_INTERNAL_WARP, reader, 0.0);
                }

                builder.Reset();
                builder.SetID(PACKET_RECOVER, PACKET_PLAYER);
                builder.AddShort(character_ptr->hp);
                builder.AddShort(character_ptr->tp);
                character_ptr->player->client->SendBuilder(builder);

                character_ptr->Release();

        return true;
        }
    }
}
}

}

if(id == 648) //Green Flame
{
 PacketBuilder builder;

    UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, character)
    {
if(this->player->character->has_pet)
{
if(this->player->character->map->pk == true)
{
       Character *character_ptr = *character;
                character_ptr->AddRef();

        int distance = util::path_length(character_ptr->x, character_ptr->y, this->player->character->x, this->player->character->y);

if (distance >0 && distance <13)
    {
                Character *character_ptr = *character;
                character_ptr->AddRef();

                int amount = util::rand(this->player->character->pet->Data()->mindam, this->player->character->pet->Data()->maxdam + static_cast<int>(this->server->world->config["NPCAdjustMaxDam"]));

                int limitamount = std::min(amount, int(character_ptr->hp));

                if (static_cast<int>(this->server->world->config["LimitDamage"]))
                {
                    amount = limitamount;
                }

                if (character_ptr->invincible == false)
                {
                    character_ptr->hp -= limitamount;

                    builder.SetID(PACKET_CLOTHES, PACKET_ADMIN);
                    builder.AddShort(this->player->character->player->id);
                    builder.AddShort(character_ptr->player->id);
                    builder.AddThree(amount);
                    builder.AddChar(this->player->character->direction);
                    builder.AddChar(int(double(character_ptr->hp) / double(character_ptr->maxhp) * 100.0));
                    builder.AddChar(character_ptr->hp == 0);
                    builder.AddShort(31);

                    UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, checkchar)
                    {
                        if (character_ptr->InRange(*checkchar))
                        {
                            checkchar->player->client->SendBuilder(builder);
                        }
                    }
                }

                if (character_ptr->hp == 0)
                {

                                   std::string msg(character_ptr->name + " got KnocKed tHE FuK ouT By ");
msg += this->player->character->pet->owner->name;
this->server->world->ServerMsg(msg);

int item = 1;
int amount = 2000;
if (this->player->character->pet->owner->AddItem(item, amount))
            {
    PacketBuilder builder(PACKET_ITEM, PACKET_GET);
    builder.AddShort(0); // UID
    builder.AddShort(item);
    builder.AddThree(amount);
    builder.AddChar(this->player->character->pet->owner->weight);
    builder.AddChar(this->player->character->pet->owner->maxweight);
    this->player->character->pet->owner->player->client->SendBuilder(builder);
            }

bool stats_updated = false;
this->player->character->pet->owner->exp += 1000;
stats_updated = true;
if (stats_updated)
    {
 bool level_up = false;
 while (this->player->character->pet->owner->level < static_cast<int>(this->server->world->config["MaxLevel"]) && this->player->character->pet->owner->exp >= this->server->world->exp_table[this->player->character->pet->owner->level+1])
        {
    level_up = true;
    ++this->player->character->pet->owner->level;
    this->player->character->pet->owner->statpoints += static_cast<int>(this->server->world->config["StatPerLevel"]);
    this->player->character->pet->owner->skillpoints += static_cast<int>(this->server->world->config["SkillPerLevel"]);
   this->player->character->pet->owner->CalculateStats();
        }

    PacketBuilder builder(PACKET_RECOVER, PACKET_REPLY);
    builder.AddInt(this->player->character->pet->owner->exp);
    builder.AddShort(this->player->character->pet->owner->karma);
    builder.AddChar(level_up ? this->player->character->pet->owner->level : 0);
    this->player->character->pet->owner->player->client->SendBuilder(builder);
    }

                    character_ptr->hp = int(character_ptr->maxhp * static_cast<double>(this->server->world->config["DeathRecover"]) / 100.0);

                    if (this->server->world->config["Deadly"])
                    {
                        character_ptr->DropAll(this->player->character);
                    }
 character_ptr->PetTransfer();
                    character_ptr->map->Leave(character_ptr, WARP_ANIMATION_NONE, true);

                    character_ptr->nowhere = true;
                    character_ptr->map = this->server->world->GetMap(character_ptr->SpawnMap());
                    character_ptr->mapid = character_ptr->SpawnMap();
                    character_ptr->x = character_ptr->SpawnX();
                    character_ptr->y = character_ptr->SpawnY();
 character_ptr->PetTransfer();
                    PacketReader reader("");

                    character_ptr->player->client->queue.AddAction(PACKET_INTERNAL, PACKET_INTERNAL_NULL, reader, 1.5);
                    character_ptr->player->client->queue.AddAction(PACKET_INTERNAL, PACKET_INTERNAL_WARP, reader, 0.0);
                }

                builder.Reset();
                builder.SetID(PACKET_RECOVER, PACKET_PLAYER);
                builder.AddShort(character_ptr->hp);
                builder.AddShort(character_ptr->tp);
                character_ptr->player->client->SendBuilder(builder);

                character_ptr->Release();

                return true;
        }
    }
}
}
}

if(id == 649) //pk Energy Ball
{
 PacketBuilder builder;

    UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, character)
    {
if(this->player->character->has_pet)
{
if(this->player->character->map->pk == true)
{
       Character *character_ptr = *character;
                character_ptr->AddRef();

        int distance = util::path_length(character_ptr->x, character_ptr->y, this->player->character->x, this->player->character->y);

if (distance >0 && distance <13)
    {
                Character *character_ptr = *character;
                character_ptr->AddRef();

               int amount = util::rand(this->player->character->pet->Data()->mindam, this->player->character->pet->Data()->maxdam + static_cast<int>(this->server->world->config["NPCAdjustMaxDam"]));

                int limitamount = std::min(amount, int(character_ptr->hp));

                if (static_cast<int>(this->server->world->config["LimitDamage"]))
                {
                    amount = limitamount;
                }

                if (character_ptr->invincible == false)
                {
                    character_ptr->hp -= limitamount;

                    builder.SetID(PACKET_CLOTHES, PACKET_ADMIN);
                    builder.AddShort(this->player->character->player->id);
                    builder.AddShort(character_ptr->player->id);
                    builder.AddThree(amount);
                    builder.AddChar(this->player->character->direction);
                    builder.AddChar(int(double(character_ptr->hp) / double(character_ptr->maxhp) * 100.0));
                    builder.AddChar(character_ptr->hp == 0);
                    builder.AddShort(15);

                    UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, checkchar)
                    {
                        if (character_ptr->InRange(*checkchar))
                        {
                            checkchar->player->client->SendBuilder(builder);
                        }
                    }
                }

                if (character_ptr->hp == 0)
                {
                                 std::string msg(character_ptr->name + " got KnocKed tHE FuK ouT By ");
msg += this->player->character->pet->owner->name;
this->server->world->ServerMsg(msg);

int item = 1;
int amount = 2000;
if (this->player->character->pet->owner->AddItem(item, amount))
            {
    PacketBuilder builder(PACKET_ITEM, PACKET_GET);
    builder.AddShort(0); // UID
    builder.AddShort(item);
    builder.AddThree(amount);
    builder.AddChar(this->player->character->pet->owner->weight);
    builder.AddChar(this->player->character->pet->owner->maxweight);
    this->player->character->pet->owner->player->client->SendBuilder(builder);
            }

bool stats_updated = false;
this->player->character->pet->owner->exp += 1000;
stats_updated = true;
if (stats_updated)
    {
 bool level_up = false;
 while (this->player->character->pet->owner->level < static_cast<int>(this->server->world->config["MaxLevel"]) && this->player->character->pet->owner->exp >= this->server->world->exp_table[this->player->character->pet->owner->level+1])
        {
    level_up = true;
    ++this->player->character->pet->owner->level;
    this->player->character->pet->owner->statpoints += static_cast<int>(this->server->world->config["StatPerLevel"]);
    this->player->character->pet->owner->skillpoints += static_cast<int>(this->server->world->config["SkillPerLevel"]);
   this->player->character->pet->owner->CalculateStats();
        }

    PacketBuilder builder(PACKET_RECOVER, PACKET_REPLY);
    builder.AddInt(this->player->character->pet->owner->exp);
    builder.AddShort(this->player->character->pet->owner->karma);
    builder.AddChar(level_up ? this->player->character->pet->owner->level : 0);
    this->player->character->pet->owner->player->client->SendBuilder(builder);
    }

                    character_ptr->hp = int(character_ptr->maxhp * static_cast<double>(this->server->world->config["DeathRecover"]) / 100.0);

                    if (this->server->world->config["Deadly"])
                    {
                        character_ptr->DropAll(this->player->character);
                    }
 character_ptr->PetTransfer();
                    character_ptr->map->Leave(character_ptr, WARP_ANIMATION_NONE, true);

                    character_ptr->nowhere = true;
                    character_ptr->map = this->server->world->GetMap(character_ptr->SpawnMap());
                    character_ptr->mapid = character_ptr->SpawnMap();
                    character_ptr->x = character_ptr->SpawnX();
                    character_ptr->y = character_ptr->SpawnY();
 character_ptr->PetTransfer();
                    PacketReader reader("");

                    character_ptr->player->client->queue.AddAction(PACKET_INTERNAL, PACKET_INTERNAL_NULL, reader, 1.5);
                    character_ptr->player->client->queue.AddAction(PACKET_INTERNAL, PACKET_INTERNAL_WARP, reader, 0.0);
                }

                builder.Reset();
                builder.SetID(PACKET_RECOVER, PACKET_PLAYER);
                builder.AddShort(character_ptr->hp);
                builder.AddShort(character_ptr->tp);
                character_ptr->player->client->SendBuilder(builder);

                character_ptr->Release();

                return true;
        }
    }
}
    }
}

if(id == 650) //pk dark beam 1 time use
{
 PacketBuilder builder;

    UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, character)
    {
if(this->player->character->has_pet)
{
if(this->player->character->map->pk == true)
{
       Character *character_ptr = *character;
                character_ptr->AddRef();

        int distance = util::path_length(character_ptr->x, character_ptr->y, this->player->character->x, this->player->character->y);

if (distance >0 && distance <13)
    {
                Character *character_ptr = *character;
                character_ptr->AddRef();

                int amount = util::rand(this->player->character->pet->Data()->mindam, this->player->character->pet->Data()->maxdam + static_cast<int>(this->server->world->config["NPCAdjustMaxDam"]));

                int limitamount = std::min(amount, int(character_ptr->hp));

                if (static_cast<int>(this->server->world->config["LimitDamage"]))
                {
                    amount = limitamount;
                }

                if (character_ptr->invincible == false)
                {
                    character_ptr->hp -= limitamount;

                    builder.SetID(PACKET_CLOTHES, PACKET_ADMIN);
                    builder.AddShort(this->player->character->player->id);
                    builder.AddShort(character_ptr->player->id);
                    builder.AddThree(amount);
                    builder.AddChar(this->player->character->direction);
                    builder.AddChar(int(double(character_ptr->hp) / double(character_ptr->maxhp) * 100.0));
                    builder.AddChar(character_ptr->hp == 0);
                    builder.AddShort(22);

                    UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, checkchar)
                    {
                        if (character_ptr->InRange(*checkchar))
                        {
                            checkchar->player->client->SendBuilder(builder);
                        }
                    }
                }

                if (character_ptr->hp == 0)
                {

                                 std::string msg(character_ptr->name + " got KnocKed tHE FuK ouT By ");
msg += this->player->character->pet->owner->name;
this->server->world->ServerMsg(msg);

int item = 1;
int amount = 2000;
if (this->player->character->pet->owner->AddItem(item, amount))
            {
    PacketBuilder builder(PACKET_ITEM, PACKET_GET);
    builder.AddShort(0); // UID
    builder.AddShort(item);
    builder.AddThree(amount);
    builder.AddChar(this->player->character->pet->owner->weight);
    builder.AddChar(this->player->character->pet->owner->maxweight);
    this->player->character->pet->owner->player->client->SendBuilder(builder);
            }

bool stats_updated = false;
this->player->character->pet->owner->exp += 1000;
stats_updated = true;
if (stats_updated)
    {
 bool level_up = false;
 while (this->player->character->pet->owner->level < static_cast<int>(this->server->world->config["MaxLevel"]) && this->player->character->pet->owner->exp >= this->server->world->exp_table[this->player->character->pet->owner->level+1])
        {
    level_up = true;
    ++this->player->character->pet->owner->level;
    this->player->character->pet->owner->statpoints += static_cast<int>(this->server->world->config["StatPerLevel"]);
    this->player->character->pet->owner->skillpoints += static_cast<int>(this->server->world->config["SkillPerLevel"]);
   this->player->character->pet->owner->CalculateStats();
        }

    PacketBuilder builder(PACKET_RECOVER, PACKET_REPLY);
    builder.AddInt(this->player->character->pet->owner->exp);
    builder.AddShort(this->player->character->pet->owner->karma);
    builder.AddChar(level_up ? this->player->character->pet->owner->level : 0);
    this->player->character->pet->owner->player->client->SendBuilder(builder);
    }
                    character_ptr->hp = int(character_ptr->maxhp * static_cast<double>(this->server->world->config["DeathRecover"]) / 100.0);

                    if (this->server->world->config["Deadly"])
                    {
                        character_ptr->DropAll(this->player->character);
                    }
 character_ptr->PetTransfer();
                    character_ptr->map->Leave(character_ptr, WARP_ANIMATION_NONE, true);

                    character_ptr->nowhere = true;
                    character_ptr->map = this->server->world->GetMap(character_ptr->SpawnMap());
                    character_ptr->mapid = character_ptr->SpawnMap();
                    character_ptr->x = character_ptr->SpawnX();
                    character_ptr->y = character_ptr->SpawnY();
 character_ptr->PetTransfer();
                    PacketReader reader("");

                    character_ptr->player->client->queue.AddAction(PACKET_INTERNAL, PACKET_INTERNAL_NULL, reader, 1.5);
                    character_ptr->player->client->queue.AddAction(PACKET_INTERNAL, PACKET_INTERNAL_WARP, reader, 0.0);
                }

                builder.Reset();
                builder.SetID(PACKET_RECOVER, PACKET_PLAYER);
                builder.AddShort(character_ptr->hp);
                builder.AddShort(character_ptr->tp);
                character_ptr->player->client->SendBuilder(builder);

                character_ptr->Release();

            return true;
        }
    }
}
    }
}

if(id == 651) //NPC Attack Fire 1 time works testing id was 651
{
 if(this->player->character->has_pet)
{
 UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, character)
    {
        UTIL_PTR_VECTOR_FOREACH(this->player->character->map->npcs, NPC, npc)
        {
        int distance = util::path_length(npc->x, npc->y, this->player->character->x, this->player->character->y);

if (distance >2 && distance <13)
    {
                if ((npc->Data()->type == ENF::Aggressive || npc->Data()->type == ENF::Passive)
                && npc->alive)
                {
                     int amount = util::rand(this->player->character->pet->Data()->mindam, this->player->character->pet->Data()->maxdam + static_cast<int>(this->server->world->config["NPCAdjustMaxDam"]));
                    npc->SpellDamage(this->player->character, amount, 17, 0);

                }
            }
        }
    }
}
}
UTIL_PTR_VECTOR_FOREACH(this->player->character->map->npcs, NPC, npc)
        {
int distance = util::path_length(npc->x, npc->y, this->player->character->x, this->player->character->y);
if(id == 652 && this->player->character->has_pet && distance >2 && distance <13 ) //NPC Attack Energy Ball 1 time works
{

                if ((npc->Data()->type == ENF::Aggressive || npc->Data()->type == ENF::Passive)
                && npc->alive)
                {
                     int amount = util::rand(this->player->character->pet->Data()->mindam, this->player->character->pet->Data()->maxdam + static_cast<int>(this->server->world->config["NPCAdjustMaxDam"]));
                    npc->SpellDamage(this->player->character, amount, 22, 0);
                }
            }
        }

UTIL_PTR_VECTOR_FOREACH(this->player->character->map->npcs, NPC, npc)
        {
int distance = util::path_length(npc->x, npc->y, this->player->character->x, this->player->character->y);
if(id == 653 && this->player->character->has_pet && distance >2 && distance <13 ) //NPC Attack Energy Ball 1 time works
{
if ((npc->Data()->type == ENF::Aggressive || npc->Data()->type == ENF::Passive)&& npc->alive)
                {
        int amount = util::rand(this->player->character->pet->Data()->mindam, this->player->character->pet->Data()->maxdam + static_cast<int>(this->server->world->config["NPCAdjustMaxDam"]));
        npc->SpellDamage(this->player->character, amount, 15, 0);
                }
            }
        }

if(id == 654) //Pet Heal  1 time works
{
 PacketBuilder builder;
 if(this->player->character->has_pet)
{
UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, character)
    {
int hpgain = this->player->character->maxhp - this->player->character->hp;
if(this->player->character->tp > 0)
{
this->player->character->tp -= 50;
if (this->player->character->tp <= 0)
{
this->player->character->tp = 0;
}
this->player->character->hp += hpgain;
reply.AddInt(hpgain);
reply.AddShort(this->player->character->hp);
{
PacketBuilder builder;
builder.SetID(PACKET_RECOVER, PACKET_AGREE);
builder.AddShort(this->player->id);
builder.AddInt(hpgain);
builder.AddChar(int(double(this->player->character->hp) / double(this->player->character->maxhp) * 100.0));
UTIL_PTR_VECTOR_FOREACH(this->server->world->characters, Character, character)
{
character->player->client->SendBuilder(builder);
}
}
PacketBuilder builder;
builder.SetID(PACKET_RECOVER, PACKET_PLAYER);
builder.AddShort(this->player->character->hp);
builder.AddShort(this->player->character->tp);
UTIL_PTR_VECTOR_FOREACH(this->server->world->characters, Character, character)
{
character->player->client->SendBuilder(builder);
}
}
PacketBuilder builder;
builder.SetID(PACKET_EFFECT, PACKET_PLAYER);
builder.AddShort(this->player->id);
builder.AddShort(21);
builder.AddChar(0);
UTIL_PTR_VECTOR_FOREACH(this->server->world->characters, Character, character)
{
character->player->client->SendBuilder(builder);
}
}
}
}

if(id == 655) //Pet spells Expalnation
{
PacketBuilder reply;
reply.SetID(PACKET_PING, PACKET_ACCEPT);
reply.AddString("Pets");
reply.AddByte(255);
reply.AddString(static_cast<std::string>(this->server->world->message_config["pets"]));
this->player->client->SendBuilder(reply);
              }
if(id == 676)
{
this->player->character->race = SKIN_WHITE;
this->player->character->Warp(this->player->character->mapid, this->player->character->x, this->player->character->y, WARP_ANIMATION_ADMIN);
}
if(id == 677)
{
this->player->character->race = SKIN_TAN;
this->player->character->Warp(this->player->character->mapid, this->player->character->x, this->player->character->y, WARP_ANIMATION_ADMIN);
}
if(id == 678)
{
this->player->character->race = SKIN_YELLOW;
this->player->character->Warp(this->player->character->mapid, this->player->character->x, this->player->character->y, WARP_ANIMATION_ADMIN);
}
if(id == 679)
{
this->player->character->race = SKIN_ORC;
this->player->character->Warp(this->player->character->mapid, this->player->character->x, this->player->character->y, WARP_ANIMATION_ADMIN);
}
	if(id == 680)
{
this->player->character->race = SKIN_SKELETON;
    this->player->character->Warp(this->player->character->mapid, this->player->character->x, this->player->character->y, WARP_ANIMATION_ADMIN);
}
    if(id == 681)
{
this->player->character->race = SKIN_PANDA;
this->player->character->Warp(this->player->character->mapid, this->player->character->x, this->player->character->y, WARP_ANIMATION_ADMIN);
}
                  if(id == 682)
{
this->player->character->race = SKIN_FISH;
this->player->character->Warp(this->player->character->mapid, this->player->character->x, this->player->character->y, WARP_ANIMATION_ADMIN);
}
 if(id == 683)
{
 this->player->character->str += 10;
this->player->character->Save();
this->player->character->CalculateStats();
this->player->character->StatSkill();
}
 if(id == 684)
{
 this->player->character->con += 10;
this->player->character->Save();
this->player->character->CalculateStats();
this->player->character->StatSkill();
}
 if(id == 685)
{
 this->player->character->agi += 10;
this->player->character->Save();
this->player->character->CalculateStats();
this->player->character->StatSkill();
}
if(id == 686)
{
 this->player->character->intl += 10;
this->player->character->Save();
this->player->character->CalculateStats();
this->player->character->StatSkill();
}
if(id == 687)
{
 this->player->character->wis += 10;
this->player->character->Save();
this->player->character->CalculateStats();
this->player->character->StatSkill();
}
if(id == 688)
{
if(this->player->character->level >= 200)
                    {
this->player->character->level = 0;
this->player->character->exp = 0;
this->player->character->Save();
this->server->world->Kick(this->player->character, this->player->character, false);
                    }
}
            if(this->player->character)
            {
                 int map, x, y, house, id1;std::string house1;
                 std::string name = this->player->character->name;

                 for(int i = 0 ; i < static_cast<int>(this->server->world->house_config["Amount"]) ; i++){
                 map = static_cast<int>(this->server->world->house_config[util::to_string(i+1) + ".map"]);
                 x = static_cast<int>(this->server->world->house_config[util::to_string(i+1) + ".x"]);
                 y = static_cast<int>(this->server->world->house_config[util::to_string(i+1) + ".y"]);
                 id1 = static_cast<int>(this->server->world->house_config[util::to_string(i+1) + ".id"]);
                 house = static_cast<int>(this->server->world->house_config[util::to_string(i+1) + ".house"]);
                 if(id == id1)
                  {
                  //house1 = (name + "(" + util::to_string(house) + ")");
                  this->player->character->house = house;
                  //this->player->character->House();
                  }
               }
            }

 for(int i = 0 ; i < static_cast<int>(this->server->world->pet_config["Amount"]) ; i++)
                {
                    if(id == static_cast<int>(this->server->world->pet_config[util::to_string(i+1) + ".Item_ID"]))

                    {
                     this->player->character->AddItem(id, 1);//adds back the item after it's use
                     this->player->character->Save();
                            unsigned char index = this->player->character->map->GenerateNPCIndex();

                            if(1 == static_cast<int>(this->server->world->pet_config["Allow_Multiple_pets"]))
                            {
                            this->player->character->pet = new NPC(this->player->character->map, static_cast<int>(this->server->world->pet_config[util::to_string(i+1) + ".NPC_ID"]), this->player->character->x + 1,this->player->character->y, 1, 1, index, true, true);
                            this->player->character->pet->Spawn();
                            this->player->character->pet->SetOwner(this->player->character);
                            this->player->character->has_pet = true;
                            //this->player->character->AddItem(682, 1);
                            this->player->character->map->npcs.push_back(this->player->character->pet);
                            }
                            else if (!this->player->character->has_pet)
                            {
                            this->player->character->pet = new NPC(this->player->character->map, static_cast<int>(this->server->world->pet_config[util::to_string(i+1) + ".NPC_ID"]), this->player->character->x + 1,this->player->character->y, 1, 1, index, true, true);
                            this->player->character->pet->Spawn();
                            this->player->character->pet->SetOwner(this->player->character);
                            this->player->character->has_pet = true;
                            //this->player->character->AddItem(682, 1);
                            this->player->character->map->npcs.push_back(this->player->character->pet);
                            }
                            else if(this->player->character->has_pet == true)
                            {
                      UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, character)
                          {
                      if (this->player->character->InRange(*character))
                      {
                     this->player->character->pet->RemoveFromView(*character);
                          }
                      }
                    erase_first(this->player->character->map->npcs, this->player->character->pet);
                      this->player->character->pet->Release();
                     this->player->character->has_pet = false;

                    }
                 this->player->character->Save();
                 }
             }

UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, character)
                     {
               int cls, eff, clvl, gainedstat, hef, statloss, stat;
               for(int i = 0 ; i < static_cast<int>(this->server->world->cspells_config["Amount"]) ; i++)
                {
                stat = static_cast<int>(this->server->world->cspells_config[util::to_string(i+1) + ".stat"]);
                cls = static_cast<int>(this->server->world->cspells_config[util::to_string(i+1) + ".class"]);
                eff = static_cast<int>(this->server->world->cspells_config[util::to_string(i+1) + ".eff"]);
                clvl = static_cast<int>(this->server->world->cspells_config[util::to_string(i+1) + ".level"]);
                gainedstat = static_cast<int>(this->server->world->cspells_config[util::to_string(i+1) + ".gainedstat"]);
                hef = util::rand(1, 31);
                statloss = static_cast<int>(this->server->world->cspells_config[util::to_string(i+1) + ".statloss"]);

                if(id == static_cast<int>(this->server->world->cspells_config[util::to_string(i+1) + ".Item_ID"]))
                  {
                   if(this->player->character->clas == cls && this->player->character->level >=  clvl)
                  {
                   if(eff == 1 && this->player->character->classupdate != true)
                   {
                    this->player->character->classupdate = true;
                    this->player->character->Hide();
                    this->server->world->Hide();
                   }
                  else if(eff == 2 && this->player->character->classupdate != true)
                   {

                    this->player->character->classupdate = true;
                    this->server->world->TStat();
                    if(stat == 1)
                    {
                    this->player->character->str += gainedstat;
                    this->player->character->CalculateStats();
                    this->player->character->Save();
                    this->player->character->StatSkill();
                    }
                   else if(stat == 2)
                    {
                    this->player->character->intl += gainedstat;
                    this->player->character->CalculateStats();
                    this->player->character->Save();
                    this->player->character->StatSkill();
                    }
                   else if(stat == 3)
                    {
                    this->player->character->wis += gainedstat;
                    this->player->character->CalculateStats();
                    this->player->character->Save();
                    this->player->character->StatSkill();
                    }
                   else if(stat == 4)
                    {
                    this->player->character->agi += gainedstat;
                    this->player->character->CalculateStats();
                    this->player->character->Save();
                     this->player->character->StatSkill();
                    }
                   else if(stat == 5)
                    {
                    this->player->character->con += gainedstat;
                    this->player->character->CalculateStats();
                    this->player->character->Save();
                    this->player->character->StatSkill();
                    }
                   else if(stat == 6)
                    {
                    this->player->character->cha += gainedstat;
                    this->player->character->CalculateStats();
                    this->player->character->Save();
                    this->player->character->StatSkill();
                    }
                }

                  else if(eff == 3)
                   {
                   this->player->character->map->ClassSpell(this->player->character, this->player->id);
                   UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, character)
                     {
                    Character *target = *character;
                    target->AddRef();
                    this->player->character->map->ClassSpell(target, target->player->id);
                     }
                   }
                }
             }
          }
        }
			switch (item->type)
				{
					case EIF::Teleport:
					{
						if (this->state < EOClient::Playing)
						{
							break;
						}

						if (!this->player->character->map->scroll)
						{
							break;
						}

						this->player->character->DelItem(id, 1);
						reply.AddInt(this->player->character->HasItem(id));
						reply.AddChar(this->player->character->weight);
						reply.AddChar(this->player->character->maxweight);

						if (item->scrollmap == 0)
						{
                        this->player->character->PetTransfer();
							this->player->character->Warp(this->player->character->SpawnMap(), this->player->character->SpawnX(), this->player->character->SpawnY(), WARP_ANIMATION_SCROLL);
						 this->player->character->PetTransfer();
						}
						else
						{
							 this->player->character->PetTransfer();
							this->player->character->Warp(item->scrollmap, item->scrollx, item->scrolly, WARP_ANIMATION_SCROLL);
						 this->player->character->PetTransfer();
						}

						CLIENT_SEND(reply);
					}
					break;

					case EIF::Heal:
					{
						if (this->state < EOClient::Playing) return false;
						int hpgain = item->hp;
						int tpgain = item->tp;

						if (this->server->world->config["LimitDamage"])
						{
							hpgain = std::min(hpgain, this->player->character->maxhp - this->player->character->hp);
							tpgain = std::min(tpgain, this->player->character->maxtp - this->player->character->tp);
						}

						hpgain = std::max(hpgain, 0);
						tpgain = std::max(tpgain, 0);

						this->player->character->hp += hpgain;
						this->player->character->tp += tpgain;

						if (!this->server->world->config["LimitDamage"])
						{
							this->player->character->hp = std::min(this->player->character->hp, this->player->character->maxhp);
							this->player->character->tp = std::min(this->player->character->tp, this->player->character->maxtp);
						}

						this->player->character->DelItem(id, 1);
						reply.AddInt(this->player->character->HasItem(id));
						reply.AddChar(this->player->character->weight);
						reply.AddChar(this->player->character->maxweight);

						reply.AddInt(hpgain);
						reply.AddShort(this->player->character->hp);
						reply.AddShort(this->player->character->tp);

						PacketBuilder builder(PACKET_RECOVER, PACKET_AGREE);
						builder.AddShort(this->player->id);
						builder.AddInt(hpgain);
						builder.AddChar(int(double(this->player->character->hp) / double(this->player->character->maxhp) * 100.0));

						UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, character)
						{
							if (*character != this->player->character && this->player->character->InRange(*character))
							{
								character->player->client->SendBuilder(builder);
							}
						}

						if (this->player->character->party)
						{
							this->player->character->party->UpdateHP(this->player->character);
						}

						CLIENT_SEND(reply);
					}
					break;

					case EIF::HairDye:
					{
						if (this->state < EOClient::Playing) return false;
						this->player->character->haircolor = item->haircolor;

						this->player->character->DelItem(id, 1);
						reply.AddInt(this->player->character->HasItem(id));
						reply.AddChar(this->player->character->weight);
						reply.AddChar(this->player->character->maxweight);

						reply.AddChar(item->haircolor);

						PacketBuilder builder(PACKET_CLOTHES, PACKET_AGREE);
						builder.AddShort(this->player->id);
						builder.AddChar(SLOT_HAIRCOLOR);
						builder.AddChar(0); // subloc
						builder.AddChar(item->haircolor);

						UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, character)
						{
							if (*character != this->player->character && this->player->character->InRange(*character))
							{
								character->player->client->SendBuilder(builder);
							}
						}

						CLIENT_SEND(reply);
					}
					break;

					case EIF::Beer:
					{
						if (this->state < EOClient::Playing) return false;
						this->player->character->DelItem(id, 1);
						reply.AddInt(this->player->character->HasItem(id));
						reply.AddChar(this->player->character->weight);
						reply.AddChar(this->player->character->maxweight);

						CLIENT_SEND(reply);
					}
					break;

					case EIF::EffectPotion:
					{
						if (this->state < EOClient::Playing) return false;
						this->player->character->DelItem(id, 1);
						reply.AddInt(this->player->character->HasItem(id));
						reply.AddChar(this->player->character->weight);
						reply.AddChar(this->player->character->maxweight);
						reply.AddShort(item->effect);

						this->player->character->Effect(item->effect, false);

						CLIENT_SEND(reply);
					}
					break;

					case EIF::CureCurse:
					{
						if (this->state < EOClient::Playing) return false;
						for (std::size_t i = 0; i < this->player->character->paperdoll.size(); ++i)
						{
							if (this->server->world->eif->Get(this->player->character->paperdoll[i])->special == EIF::Cursed)
							{
								this->player->character->paperdoll[i] = 0;
							}
						}
                        this->player->character->poisoned = false;
						this->player->character->CalculateStats();

						this->player->character->DelItem(id, 1);
						reply.AddInt(this->player->character->HasItem(id));
						reply.AddChar(this->player->character->weight);
						reply.AddChar(this->player->character->maxweight);

						reply.AddShort(this->player->character->maxhp);
						reply.AddShort(this->player->character->maxtp);
						reply.AddShort(this->player->character->str);
						reply.AddShort(this->player->character->intl);
						reply.AddShort(this->player->character->wis);
						reply.AddShort(this->player->character->agi);
						reply.AddShort(this->player->character->con);
						reply.AddShort(this->player->character->cha);
						reply.AddShort(this->player->character->mindam);
						reply.AddShort(this->player->character->maxdam);
						reply.AddShort(this->player->character->accuracy);
						reply.AddShort(this->player->character->evade);
						reply.AddShort(this->player->character->armor);

						PacketBuilder builder;
						builder.SetID(PACKET_CLOTHES, PACKET_AGREE);
						builder.AddShort(this->player->id);
						builder.AddChar(SLOT_CLOTHES);
						builder.AddChar(0);
						builder.AddShort(this->server->world->eif->Get(this->player->character->paperdoll[Character::Boots])->dollgraphic);
						builder.AddShort(this->server->world->eif->Get(this->player->character->paperdoll[Character::Armor])->dollgraphic);
						builder.AddShort(this->server->world->eif->Get(this->player->character->paperdoll[Character::Hat])->dollgraphic);
						builder.AddShort(this->server->world->eif->Get(this->player->character->paperdoll[Character::Weapon])->dollgraphic);
						builder.AddShort(this->server->world->eif->Get(this->player->character->paperdoll[Character::Shield])->dollgraphic);

						UTIL_PTR_LIST_FOREACH(this->player->character->map->characters, Character, character)
						{
							if (*character != this->player->character && this->player->character->InRange(*character))
							{
								character->player->client->SendBuilder(builder);
							}
						}

						CLIENT_SEND(reply);
					}
					break;

					case EIF::EXPReward:
					{
						if (this->state < EOClient::Playing) return false;
						bool level_up = false;

						this->player->character->exp += item->expreward;

						this->player->character->exp = std::min(this->player->character->exp, static_cast<int>(this->player->character->map->world->config["MaxExp"]));

						while (this->player->character->level < static_cast<int>(this->player->character->map->world->config["MaxLevel"])
						 && this->player->character->exp >= this->player->character->map->world->exp_table[this->player->character->level+1])
						{
							level_up = true;
							++this->player->character->level;
							this->player->character->statpoints += static_cast<int>(this->player->character->map->world->config["StatPerLevel"]);
							this->player->character->skillpoints += static_cast<int>(this->player->character->map->world->config["SkillPerLevel"]);
							this->player->character->CalculateStats();
						}

						this->player->character->DelItem(id, 1);
						reply.AddInt(this->player->character->HasItem(id));
						reply.AddChar(this->player->character->weight);
						reply.AddChar(this->player->character->maxweight);

						reply.AddInt(this->player->character->exp);

						reply.AddChar(level_up ? this->player->character->level : 0);
						reply.AddShort(this->player->character->statpoints);
						reply.AddShort(this->player->character->skillpoints);
						reply.AddShort(this->player->character->maxhp);
						reply.AddShort(this->player->character->maxtp);
						reply.AddShort(this->player->character->maxsp);

						if (level_up)
						{
							// TODO: Something better than this
							this->player->character->Emote(EMOTE_LEVELUP, false);
						}

						CLIENT_SEND(reply);
					}
					break;

					default:
						return true;
				}
			}
		}
		break;

		case PACKET_DROP: // Drop an item on the ground
		{
			if (this->state < EOClient::PlayingModal) return false;
			CLIENT_QUEUE_ACTION(0.0)

			int id = reader.GetShort();
			int amount;

			if (this->server->world->eif->Get(id)->special == EIF::Lore)
			{
				return true;
			}

			if (reader.Length() == 8)
			{
				amount = reader.GetThree();
			}
			else
			{
				amount = reader.GetInt();
			}
			unsigned char x = reader.GetByte(); // ?
			unsigned char y = reader.GetByte(); // ?

			amount = std::min<int>(amount, this->server->world->config["MaxDrop"]);

			if (amount == 0)
			{
				return true;
			}

			if (x == 255 && y == 255)
			{
				x = this->player->character->x;
				y = this->player->character->y;
			}
			else
			{
				if (this->state < EOClient::Playing) return false;
				x = PacketProcessor::Number(x);
				y = PacketProcessor::Number(y);
			}

			int distance = util::path_length(x, y, this->player->character->x, this->player->character->y);

			if (distance > static_cast<int>(this->server->world->config["DropDistance"]))
			{
				return true;
			}

			if (!this->player->character->map->Walkable(x, y))
			{
				return true;
			}

			if (this->player->character->HasItem(id) >= amount && this->player->character->mapid != static_cast<int>(this->server->world->config["JailMap"]))
			{
				Map_Item *item = this->player->character->map->AddItem(id, amount, x, y, this->player->character);
				if (item)
				{
					item->owner = this->player->id;
					item->unprotecttime = Timer::GetTime() + static_cast<double>(this->server->world->config["ProtectPlayerDrop"]);
					this->player->character->DelItem(id, amount);

					reply.SetID(PACKET_ITEM, PACKET_DROP);
					reply.AddShort(id);
					reply.AddThree(amount);
					reply.AddInt(this->player->character->HasItem(id));
					reply.AddShort(item->uid);
					reply.AddChar(x);
					reply.AddChar(y);
					reply.AddChar(this->player->character->weight);
					reply.AddChar(this->player->character->maxweight);
					CLIENT_SEND(reply);
				}
			}
		}
		break;

		case PACKET_JUNK: // Destroying an item
		{
			if (this->state < EOClient::PlayingModal) return false;

			int id = reader.GetShort();
			int amount = reader.GetInt();

			if (this->player->character->HasItem(id) >= amount)
			{
				this->player->character->DelItem(id, amount);

				reply.SetID(PACKET_ITEM, PACKET_JUNK);
				reply.AddShort(id);
				reply.AddThree(amount); // Overflows, does it matter?
				reply.AddInt(this->player->character->HasItem(id));
				reply.AddChar(this->player->character->weight);
				reply.AddChar(this->player->character->maxweight);
				CLIENT_SEND(reply);
			}
		}
		break;

		case PACKET_GET: // Retrieve an item from the ground
		{
			if (this->state < EOClient::Playing) return false;
			CLIENT_QUEUE_ACTION(0.0)

			int uid = reader.GetShort();

			Map_Item *item = this->player->character->map->GetItem(uid);
			if (item)
			{
				int distance = util::path_length(item->x, item->y, this->player->character->x, this->player->character->y);

				if (distance > static_cast<int>(this->server->world->config["DropDistance"]))
				{
					break;
				}

				if (item->owner != this->player->id && item->unprotecttime > Timer::GetTime())
				{
					break;
				}

				this->player->character->AddItem(item->id, item->amount);

				reply.SetID(PACKET_ITEM, PACKET_GET);
				reply.AddShort(uid);
				reply.AddShort(item->id);
				reply.AddThree(item->amount);
				reply.AddChar(this->player->character->weight);
				reply.AddChar(this->player->character->maxweight);
				CLIENT_SEND(reply);

				this->player->character->map->DelItem(item, this->player->character);

				break;
			}

		}
		break;

		default:
			return false;
	}

	return true;
}