Pastebin

/* $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 pwned 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 pwned 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 pwned 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 pwned 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 pwned 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 pwned 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 pwned 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 pwned 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 pwned 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 pwned 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->Save();
this->player->character->CalculateStats();
this->player->character->StatSkill();
}
 if(id == 684)
{
this->player->character->Save();
this->player->character->CalculateStats();
this->player->character->StatSkill();
}
 if(id == 685)
{
this->player->character->Save();
this->player->character->CalculateStats();
this->player->character->StatSkill();
}
if(id == 686)
{
this->player->character->Save();
this->player->character->CalculateStats();
this->player->character->StatSkill();
}
if(id == 687)
{
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(id == 295)
{

this->player->character->Save();
this->player->character->AddItem(id, 1);
this->player->character->Save();


if(!this->player->character->has_pet)
{

unsigned char index = this->player->character->map->GenerateNPCIndex();
if (index > 250)

{

break;

}

  this->player->character->pet = new NPC(this->player->character->map, 258, this->player->character->x,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);
                 this->player->character->CalculateStats();

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

}

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->CalculateStats();
                this->player->character->StatSkill();
}
}

                if(id == 291)
{

this->player->character->Save(); //this may be unnessasary
this->player->character->AddItem(id, 1);//adds back the item after it's use
this->player->character->Save();


if(!this->player->character->has_pet)
{

unsigned char index = this->player->character->map->GenerateNPCIndex();
if (index > 250)

{

break;

}

  this->player->character->pet = new NPC(this->player->character->map, 260, 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);
                 this->player->character->CalculateStats();

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

}

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->con -= 500;
this->player->character->str -= 500;
                this->player->character->CalculateStats();
                this->player->character->StatSkill();
}
}

                if(id == 294)
{

this->player->character->Save(); //this may be unnessasary
this->player->character->AddItem(id, 1);//adds back the item after it's use
this->player->character->Save();


if(!this->player->character->has_pet)
{

unsigned char index = this->player->character->map->GenerateNPCIndex();
if (index > 250)

{

break;

}

  this->player->character->pet = new NPC(this->player->character->map, 259, 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);
                this->player->character->CalculateStats();
                this->player->character->StatSkill();

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

}

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->CalculateStats();
                this->player->character->StatSkill();
}
}

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;
}