Forum :: EOSERV :: Ok #commands Problem. Help? (Still not working, Help?)

ok i shouldnt have started a new topic but i figure i'd get more help from here.

When i try to add Thehispanic's # commands to my source, it just says this

Compiling: ..\src\handlers\Talk.cpp

C:\Users\Austin\Desktop\Flash drive\trunk\src\handlers\Talk.cpp: In member function 'bool EOClient::Handle_Talk(PacketFamily, PacketAction, PacketReader&, int)':

C:\Users\Austin\Desktop\Flash drive\trunk\src\handlers\Talk.cpp:153: error: 'class World' has no member named 'player_config'

C:\Users\Austin\Desktop\Flash drive\trunk\src\handlers\Talk.cpp:168: error: 'class Character' has no member named 'StatSkill'

Process terminated with status 1 (0 minutes, 1 seconds)

2 errors, 0 warnings

 

---
Create your own destiny, don't let someone else do it for you.

i know the second one has to do with the 'statskill' method. it isn't a method that is included by default, you have to create it yourself in the character file. Search around the forums for that. 

As for the first one, it looks like the code is asking for a variable called 'player_config' but isn't finding it. You may have either a) typed something in wrong or b) forgotten to add something in during the tutorial for adding these commands in the first place.

---
class EOSERV {
Programmer | Oldbie
Open source EO Client: https://github.com/ethanmoffat/EndlessClient
};

Lmao i didnt type anything. i copied and pasted it from thehispanics source

---
Create your own destiny, don't let someone else do it for you.

are you sure you copied everything then? Because if you had, then there wouldn't be a problem with it not being able to find the statskill method. Here, I googled it for you and found this:

void Character::StatSkill()

    PacketBuilder reply;
    {

     reply.SetID(PACKET_STATSKILL, PACKET_PLAYER);
     reply.AddShort(this->player->character->statpoints);
     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->maxhp);
     reply.AddShort(this->player->character->maxtp);
     reply.AddShort(this->player->character->maxsp);
     reply.AddShort(this->player->character->maxweight);
     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);

     this->player->client->SendBuilder(reply);
}

if you add this to your character.cpp your second problem will go away.

---
class EOSERV {
Programmer | Oldbie
Open source EO Client: https://github.com/ethanmoffat/EndlessClient
};

ethanmoffat posted: (9th Mar 2010 11:08 pm)

are you sure you copied everything then? Because if you had, then there wouldn't be a problem with it not being able to find the statskill method. Here, I googled it for you and found this:

void Character::StatSkill()

    PacketBuilder reply;
    {

     reply.SetID(PACKET_STATSKILL, PACKET_PLAYER);
     reply.AddShort(this->player->character->statpoints);
     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->maxhp);
     reply.AddShort(this->player->character->maxtp);
     reply.AddShort(this->player->character->maxsp);
     reply.AddShort(this->player->character->maxweight);
     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);

     this->player->client->SendBuilder(reply);
}

if you add this to your character.cpp your second problem willgoaway.

Ok, i'm glad that you did this, but do you know where this goes? and yes, i copied it, but only the talk.cpp part :D

---
Create your own destiny, don't let someone else do it for you.

I used to get the talk.cpp error a lot. For some reason, nothing I did would fix it. Suggestion: Copy talk.cpp from a clean source and readd the commands.

alright i just checked out the post he put up and looks like he assumed statskill and that other variable would already be there. as i said before, that command goes in your character.cpp (trunk/src/character.cpp) around line 1210. After all the other methods. Try adding that it should fix thesecond error.

-edit- just saw your reply. you also have to go into character.hpp (trunk/src/character.hpp) and add in a line that says 'void statskill();' at around line 189. It is case sensitive to whatever statskill you used before.

---
class EOSERV {
Programmer | Oldbie
Open source EO Client: https://github.com/ethanmoffat/EndlessClient
};

ahh ok Thanks ill test it immediatly.

--edit-- OK now i get this.

Compiling: ..\src\character.cpp

C:\Users\Austin\Desktop\Flash drive\trunk\src\character.cpp: In member function 'void Character::Logout()':

C:\Users\Austin\Desktop\Flash drive\trunk\src\character.cpp:1212: error: expected initializer before 'PacketBuilder'

C:\Users\Austin\Desktop\Flash drive\trunk\src\character.cpp:1215: error: 'reply' was not declared in this scope

Process terminated with status 1 (0 minutes, 2 seconds)

2 errors, 0 warnings

I get this when i compile the Character.cpp i added it on line 1210

OK now i only have 1 error the one with the Player_Config

---
Create your own destiny, don't let someone else do it for you.

"around line 1210" != "put it exactly on line 1210" i was just lazy and decided not to spell it out for you. here you go.

add it on line 1212. right after the save method. 

hopefully you just added it in and didn't replace any code because if you removed anything you will have to copy over a whole new character.cpp. 

---
class EOSERV {
Programmer | Oldbie
Open source EO Client: https://github.com/ethanmoffat/EndlessClient
};

Ok heres my Character.cpp file. i cant put it on 1212 because thats right in the middle of a code

/* $Id: character.cpp 186 2010-02-06 00:06:47Z sausage $

 * EOSERV is released under the zlib license.

 * See LICENSE.txt for more info.

 */

#include "character.hpp"

#include "arena.hpp"

#include "console.hpp"

#include "database.hpp"

#include "eoclient.hpp"

#include "eodata.hpp"

#include "map.hpp"

#include "npc.hpp"

#include "packet.hpp"

#include "party.hpp"

#include "player.hpp"

#include "world.hpp"

// TODO: Clean up these functions

std::string ItemSerialize(const PtrList<Character_Item> &list)

{

std::string serialized;

for (PtrList<Character_Item>::ConstIterator it(list); it; ++it)

{

serialized.append(util::to_string(it->id));

serialized.append(",");

serialized.append(util::to_string(it->amount));

serialized.append(";");

}

return serialized;

}

PtrList<Character_Item> ItemUnserialize(std::string serialized)

{

PtrList<Character_Item> list;

std::size_t p = 0;

std::size_t lastp = std::numeric_limits<std::size_t>::max();

if (!serialized.empty() && *(serialized.end()-1) != ';')

{

serialized.push_back(';');

}

while ((p = serialized.find_first_of(';', p+1)) != std::string::npos)

{

std::string part = serialized.substr(lastp+1, p-lastp-1);

std::size_t pp = 0;

pp = part.find_first_of(',', 0);

if (pp == std::string::npos)

{

continue;

}

Character_Item *newitem = new Character_Item;

newitem->id = util::to_int(part.substr(0, pp));

newitem->amount = util::to_int(part.substr(pp+1));

list.push_back(newitem);

newitem->Release();

lastp = p;

}

return list;

}

std::string DollSerialize(util::array<int, 15> list)

{

std::string serialized;

UTIL_ARRAY_FOREACH_ALL(list, int, 15, item)

{

serialized.append(util::to_string(item));

serialized.append(",");

}

return serialized;

}

util::array<int, 15> DollUnserialize(std::string serialized)

{

util::array<int, 15> list(0);

std::size_t p = 0;

std::size_t lastp = std::numeric_limits<std::size_t>::max();

int i = 0;

if (!serialized.empty() && *(serialized.end()-1) != ',')

{

serialized.push_back(',');

}

while ((p = serialized.find_first_of(',', p+1)) != std::string::npos)

{

list[i++] = util::to_int(serialized.substr(lastp+1, p-lastp-1));

lastp = p;

}

return list;

}

template <typename T> T GetRow(std::tr1::unordered_map<std::string, util::variant> &row, const char *col)

{

return row[col];

}

Character::Character(std::string name, World *world)

{

this->world = world;

Database_Result res = this->world->db.Query("SELECT `name`, `title`, `home`, `fiance`, `partner`, `admin`, `class`, `gender`, `race`, `hairstyle`, `haircolor`,"

"`map`, `x`, `y`, `direction`, `level`, `exp`, `hp`, `tp`, `str`, `int`, `wis`, `agi`, `con`, `cha`, `statpoints`, `skillpoints`, "

"`karma`, `sitting`, `bankmax`, `goldbank`, `usage`, `inventory`, `bank`, `paperdoll`, `spells`, `guild`, `guild_rank`, `quest`, `vars` FROM `characters` "

"WHERE `name` = '$'", name.c_str());

std::tr1::unordered_map<std::string, util::variant> row = res.front();

        this->pet = 0;

        this->has_pet = false;

        this->pet_transfer = false;

this->login_time = std::time(0);

this->online = false;

this->nowhere = false;

this->id = this->world->GenerateCharacterID();

this->admin = static_cast<AdminLevel>(GetRow<int>(row, "admin"));

this->name = GetRow<std::string>(row, "name");

this->title = GetRow<std::string>(row, "title");

this->home = GetRow<std::string>(row, "home");

this->partner = GetRow<std::string>(row, "partner");

this->clas = GetRow<int>(row, "class");

this->gender = static_cast<Gender>(GetRow<int>(row, "gender"));

this->race = static_cast<Skin>(GetRow<int>(row, "race"));

this->hairstyle = GetRow<int>(row, "hairstyle");

this->haircolor = GetRow<int>(row, "haircolor");

this->mapid = GetRow<int>(row, "map");

this->x = GetRow<int>(row, "x");

this->y = GetRow<int>(row, "y");

this->direction = static_cast<Direction>(GetRow<int>(row, "direction"));

this->level = GetRow<int>(row, "level");

this->exp = GetRow<int>(row, "exp");

this->hp = GetRow<int>(row, "hp");

this->tp = GetRow<int>(row, "tp");

this->str = GetRow<int>(row, "str");

this->intl = GetRow<int>(row, "int");

this->wis = GetRow<int>(row, "wis");

this->agi = GetRow<int>(row, "agi");

this->con = GetRow<int>(row, "con");

this->cha = GetRow<int>(row, "cha");

this->statpoints = GetRow<int>(row, "statpoints");

this->skillpoints = GetRow<int>(row, "skillpoints");

this->karma = GetRow<int>(row, "karma");

this->weight = 0;

this->maxweight = 0;

this->maxhp = 0;

this->maxtp = 0;

this->maxsp = 0;

this->mindam = 0;

this->maxdam = 0;

this->accuracy = 0;

this->evade = 0;

this->armor = 0;

this->trading = false;

this->trade_partner = 0;

this->trade_agree = false;

this->party_trust_send = 0;

this->party_trust_recv = 0;

this->npc = 0;

this->npc_type = ENF::NPC;

this->board = 0;

this->jukebox_open = false;

this->last_guild_action = 0.0;

this->next_arena = 0;

this->arena = 0;

this->warp_anim = WARP_ANIMATION_INVALID;

this->sitting = static_cast<SitAction>(GetRow<int>(row, "sitting"));

this->hidden = false;

this->bankmax = GetRow<int>(row, "bankmax");

// EOSERV originally set the default bankmax to 20

if (this->bankmax > static_cast<int>(world->config["MaxBankUpgrades"]))

{

this->bankmax = 0;

}

this->goldbank = GetRow<int>(row, "goldbank");

this->usage = GetRow<int>(row, "usage");

this->inventory = ItemUnserialize(row["inventory"]);

this->bank = ItemUnserialize(row["bank"]);

this->paperdoll = DollUnserialize(row["paperdoll"]);

this->player = 0;

std::string guild_tag = util::trim(static_cast<std::string>(row["guild"]));

if (!guild_tag.empty())

{

this->guild = this->world->guildmanager->GetGuild(guild_tag);

this->guild_rank = static_cast<int>(row["guild_rank"]);

}

else

{

this->guild = 0;

this->guild_rank = 0;

}

this->party = 0;

this->map = this->world->GetMap(0);

}

bool Character::ValidName(std::string name)

{

if (name.length() < 4)

{

return false;

}

if (name.length() > 12)

{

return false;

}

for (std::size_t i = 0; i < name.length(); ++i)

{

if (name[i] < 'a' || name[i] > 'z')

{

return false;

}

}

return true;

}

void Character::Msg(Character *from, std::string message)

{

message = util::text_cap(message, static_cast<int>(this->world->config["ChatMaxWidth"]) - util::text_width(util::ucfirst(from->name) + "  "));

PacketBuilder builder(PACKET_TALK, PACKET_TELL);

builder.AddBreakString(from->name);

builder.AddBreakString(message);

this->player->client->SendBuilder(builder);

}

void Character::ServerMsg(std::string message)

{

message = util::text_cap(message, static_cast<int>(this->world->config["ChatMaxWidth"]) - util::text_width("Server  "));

PacketBuilder builder(PACKET_TALK, PACKET_SERVER);

builder.AddString(message);

this->player->client->SendBuilder(builder);

}

bool Character::Walk(Direction direction)

{

return this->map->Walk(this, direction);

}

bool Character::AdminWalk(Direction direction)

{

return this->map->Walk(this, direction, true);

}

void Character::Attack(Direction direction)

{

this->map->Attack(this, direction);

}

void Character::Sit(SitAction sit_type)

{

this->map->Sit(this, sit_type);

}

void Character::Stand()

{

this->map->Stand(this);

}

void Character::Emote(enum Emote emote, bool echo)

{

this->map->Emote(this, emote, echo);

}

void Character::Effect(int effect, bool echo)

{

PacketBuilder builder;

builder.SetID(PACKET_EFFECT, PACKET_PLAYER);

builder.AddShort(this->player->id);

builder.AddThree(effect);

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

{

if (!echo && (*character == this || !this->InRange(*character)))

{

continue;

}

character->player->client->SendBuilder(builder);

}

}

int Character::HasItem(short item)

{

UTIL_PTR_LIST_FOREACH(this->inventory, Character_Item, it)

{

if (it->id == item)

{

if (this->trading)

{

UTIL_PTR_LIST_FOREACH(this->trade_inventory, Character_Item, tit)

{

if (tit->id == item)

{

return std::max(it->amount - tit->amount, 0);

}

}

return it->amount;

}

else

{

return it->amount;

}

}

}

return 0;

}

bool Character::AddItem(short item, int amount)

{

if (amount <= 0)

{

return false;

}

if (item <= 0 || static_cast<std::size_t>(item) >= this->world->eif->data.size())

{

return false;

}

UTIL_PTR_LIST_FOREACH(this->inventory, Character_Item, it)

{

if (it->id == item)

{

if (it->amount + amount < 0)

{

return false;

}

it->amount += amount;

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

this->CalculateStats();

return true;

}

}

Character_Item *newitem = new Character_Item;

newitem->id = item;

newitem->amount = amount;

this->inventory.push_back(newitem);

newitem->Release();

this->CalculateStats();

return true;

}

bool Character::DelItem(short item, int amount)

{

if (amount <= 0)

{

return false;

}

UTIL_PTR_LIST_FOREACH(this->inventory, Character_Item, it)

{

if (it->id == item)

{

if (it->amount < 0 || it->amount - amount <= 0)

{

this->inventory.erase(it);

}

else

{

it->amount -= amount;

}

this->CalculateStats();

return true;

}

}

return false;

}

void Character::DelItem(PtrList<Character_Item>::Iterator &it, int amount)

{

if (amount <= 0)

{

return;

}

if (it->amount < 0 || it->amount - amount <= 0)

{

this->inventory.erase(it);

}

else

{

it->amount -= amount;

}

this->CalculateStats();

}

bool Character::AddTradeItem(short item, int amount)

{

if (amount <= 0)

{

return false;

}

if (item <= 0 || static_cast<std::size_t>(item) >= this->world->eif->data.size())

{

return false;

}

int hasitem = this->HasItem(item);

if (hasitem - amount < 0)

{

return false;

}

UTIL_PTR_LIST_FOREACH(this->trade_inventory, Character_Item, it)

{

if (it->id == item)

{

it->amount += amount;

return true;

}

}

Character_Item *newitem = new Character_Item;

newitem->id = item;

newitem->amount = amount;

this->trade_inventory.push_back(newitem);

newitem->Release();

return true;

}

bool Character::DelTradeItem(short item)

{

for (PtrList<Character_Item>::Iterator it(this->trade_inventory); it; ++it)

{

if (it->id == item)

{

this->trade_inventory.erase(it);

return true;

}

}

return false;

}

bool Character::Unequip(short item, unsigned char subloc)

{

if (item == 0)

{

return false;

}

for (std::size_t i = 0; i < this->paperdoll.size(); ++i)

{

if (this->paperdoll[i] == item)

{

if (((i == Character::Ring2 || i == Character::Armlet2 || i == Character::Bracer2) ? 1 : 0) == subloc)

{

this->paperdoll[i] = 0;

this->AddItem(item, 1);

this->CalculateStats();

return true;

}

}

}

return false;

}

static bool character_equip_oneslot(Character *character, short item, unsigned char subloc, Character::EquipLocation slot)

{

if (character->paperdoll[slot] != 0)

{

return false;

}

character->paperdoll[slot] = item;

character->DelItem(item, 1);

character->CalculateStats();

return true;

}

static bool character_equip_twoslot(Character *character, short item, unsigned char subloc, Character::EquipLocation slot1, Character::EquipLocation slot2)

{

if (subloc == 0)

{

if (character->paperdoll[slot1] != 0)

{

return false;

}

character->paperdoll[slot1] = item;

character->DelItem(item, 1);

}

else

{

if (character->paperdoll[slot2] != 0)

{

return false;

}

character->paperdoll[slot2] = item;

character->DelItem(item, 1);

}

character->CalculateStats();

return true;

}

bool Character::Equip(short item, unsigned char subloc)

{

if (!this->HasItem(item))

{

return false;

}

EIF::Type type = this->world->eif->Get(item)->type;

if (type == EIF::Armor && this->world->eif->Get(item)->gender != this->gender)

{

return false;

}

switch (type)

{

case EIF::Weapon: return character_equip_oneslot(this, item, subloc, Weapon);

case EIF::Shield: return character_equip_oneslot(this, item, subloc, Shield);

case EIF::Hat: return character_equip_oneslot(this, item, subloc, Hat);

case EIF::Boots: return character_equip_oneslot(this, item, subloc, Boots);

case EIF::Gloves: return character_equip_oneslot(this, item, subloc, Gloves);

case EIF::Accessory: return character_equip_oneslot(this, item, subloc, Accessory);

case EIF::Belt: return character_equip_oneslot(this, item, subloc, Belt);

case EIF::Armor: return character_equip_oneslot(this, item, subloc, Armor);

case EIF::Necklace: return character_equip_oneslot(this, item, subloc, Necklace);

case EIF::Ring: return character_equip_twoslot(this, item, subloc, Ring1, Ring2);

case EIF::Armlet: return character_equip_twoslot(this, item, subloc, Armlet1, Armlet2);

case EIF::Bracer: return character_equip_twoslot(this, item, subloc, Bracer1, Bracer2);

default: return false;

}

}

bool Character::InRange(unsigned char x, unsigned char y)

{

return util::path_length(this->x, this->y, x, y) <= static_cast<int>(this->world->config["SeeDistance"]);

}

bool Character::InRange(Character *other)

{

if (this->nowhere || other->nowhere)

{

return false;

}

return this->InRange(other->x, other->y);

}

bool Character::InRange(NPC *other)

{

if (this->nowhere)

{

return false;

}

return this->InRange(other->x, other->y);

}

bool Character::InRange(Map_Item *other)

{

if (this->nowhere)

{

return false;

}

return this->InRange(other->x, other->y);

}

void Character::Warp(short map, unsigned char x, unsigned char y, WarpAnimation animation)

{

if (!this->world->GetMap(map)->exists)

{

return;

}

PacketBuilder builder;

builder.SetID(PACKET_WARP, PACKET_REQUEST);

if (this->mapid == map && !this->nowhere)

{

builder.AddChar(WARP_LOCAL);

builder.AddShort(map);

builder.AddChar(x);

builder.AddChar(y);

}

else

{

builder.AddChar(WARP_SWITCH);

builder.AddShort(map);

if (this->world->config["GlobalPK"] && !this->world->PKExcept(map))

{

builder.AddByte(0xFF);

builder.AddByte(0x01);

}

else

{

builder.AddByte(this->world->GetMap(map)->rid[0]);

builder.AddByte(this->world->GetMap(map)->rid[1]);

}

builder.AddByte(this->world->GetMap(map)->rid[2]);

builder.AddByte(this->world->GetMap(map)->rid[3]);

builder.AddThree(this->world->GetMap(map)->filesize);

builder.AddChar(0); // ?

builder.AddChar(0); // ?

}

if (this->map && this->map->exists)

{

this->map->Leave(this, animation);

}

this->map = this->world->GetMap(map);

this->mapid = map;

this->x = x;

this->y = y;

this->sitting = SIT_STAND;

this->npc = 0;

this->npc_type = ENF::NPC;

this->board = 0;

this->jukebox_open = false;

this->guild_join = "";

this->guild_invite = "";

this->warp_anim = animation;

this->nowhere = false;

this->map->Enter(this, animation);

this->player->client->SendBuilder(builder);

if (this->arena)

{

--this->arena->occupants;

this->arena = 0;

}

if (this->next_arena)

{

this->arena = this->next_arena;

++this->arena->occupants;

this->next_arena = 0;

}

}

void Character::Refresh()

{

PacketBuilder builder;

PtrVector<Character> updatecharacters;

PtrVector<NPC> updatenpcs;

PtrVector<Map_Item> updateitems;

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

{

if (this->InRange(*character))

{

updatecharacters.push_back(*character);

}

}

UTIL_PTR_VECTOR_FOREACH(this->map->npcs, NPC, npc)

{

if (this->InRange(*npc))

{

updatenpcs.push_back(*npc);

}

}

UTIL_PTR_LIST_FOREACH(this->map->items, Map_Item, item)

{

if (this->InRange(*item))

{

updateitems.push_back(*item);

}

}

builder.SetID(PACKET_REFRESH, PACKET_REPLY);

builder.AddChar(updatecharacters.size()); // Number of players

builder.AddByte(255);

UTIL_PTR_VECTOR_FOREACH(updatecharacters, Character, character)

{

builder.AddBreakString(character->name);

builder.AddShort(character->player->id);

builder.AddShort(character->mapid);

builder.AddShort(character->x);

builder.AddShort(character->y);

builder.AddChar(character->direction);

builder.AddChar(6); // ?

builder.AddString(character->PaddedGuildTag());

builder.AddChar(character->level);

builder.AddChar(character->gender);

builder.AddChar(character->hairstyle);

builder.AddChar(character->haircolor);

builder.AddChar(character->race);

builder.AddShort(character->maxhp);

builder.AddShort(character->hp);

builder.AddShort(character->maxtp);

builder.AddShort(character->tp);

// equipment

builder.AddShort(this->world->eif->Get(character->paperdoll[Character::Boots])->dollgraphic);

builder.AddShort(0); // ??

builder.AddShort(0); // ??

builder.AddShort(0); // ??

builder.AddShort(this->world->eif->Get(character->paperdoll[Character::Armor])->dollgraphic);

builder.AddShort(0); // ??

builder.AddShort(this->world->eif->Get(character->paperdoll[Character::Hat])->dollgraphic);

builder.AddShort(this->world->eif->Get(character->paperdoll[Character::Shield])->dollgraphic);

builder.AddShort(this->world->eif->Get(character->paperdoll[Character::Weapon])->dollgraphic);

builder.AddChar(character->sitting);

builder.AddChar(character->hidden);

builder.AddByte(255);

}

UTIL_PTR_VECTOR_FOREACH(updatenpcs, NPC, npc)

{

if (npc->alive)

{

builder.AddChar(npc->index);

builder.AddShort(npc->Data()->id);

builder.AddChar(npc->x);

builder.AddChar(npc->y);

builder.AddChar(npc->direction);

}

}

builder.AddByte(255);

UTIL_PTR_VECTOR_FOREACH(updateitems, Map_Item, item)

{

builder.AddShort(item->uid);

builder.AddShort(item->id);

builder.AddChar(item->x);

builder.AddChar(item->y);

builder.AddThree(item->amount);

}

this->player->client->SendBuilder(builder);

}

void Character::ShowBoard(Board *board)

{

if (!board)

{

board = this->board;

}

PacketBuilder builder(PACKET_BOARD, PACKET_OPEN);

builder.AddChar(board->id + 1);

builder.AddChar(board->posts.size());

int post_count = 0;

int recent_post_count = 0;

UTIL_PTR_LIST_FOREACH(board->posts, Board_Post, post)

{

if (post->author == this->player->character->name)

{

++post_count;

if (post->time + static_cast<int>(this->world->config["BoardRecentPostTime"]) > Timer::GetTime())

{

++recent_post_count;

}

}

}

int posts_remaining = std::min(static_cast<int>(this->world->config["BoardMaxUserPosts"]) - post_count, static_cast<int>(this->world->config["BoardMaxUserRecentPosts"]) - recent_post_count);

UTIL_PTR_LIST_FOREACH(board->posts, Board_Post, post)

{

builder.AddShort(post->id);

builder.AddByte(255);

std::string author_extra;

if (posts_remaining > 0)

{

author_extra = " ";

}

builder.AddBreakString(post->author + author_extra);

std::string subject_extra;

if (this->world->config["BoardDatePosts"])

{

subject_extra = " (" + util::timeago(post->time, Timer::GetTime()) + ")";

}

builder.AddBreakString(post->subject + subject_extra);

}

this->player->client->SendBuilder(builder);

}

std::string Character::PaddedGuildTag()

{

std::string tag;

if (this->world->config["ShowLevel"])

{

tag = util::to_string(this->level);

if (tag.length() < 3)

{

tag.insert(tag.begin(), 'L');

}

}

else

{

tag = this->guild ? this->guild->tag : "";

}

for (std::size_t i = tag.length(); i < 3; ++i)

{

tag.push_back(' ');

}

return tag;

}

int Character::Usage()

{

return this->usage + (std::time(0) - this->login_time) / 60;

}

short Character::SpawnMap()

{

return this->world->GetHome(this)->map;

}

unsigned char Character::SpawnX()

{

return this->world->GetHome(this)->x;

}

unsigned char Character::SpawnY()

{

return this->world->GetHome(this)->y;

}

// TODO: calculate equipment bonuses, check formulas

void Character::CalculateStats()

{

short calcstr = this->str;

short calcintl = this->intl;

short calcwis = this->wis;

short calcagi = this->agi;

short calccon = this->con;

short calccha = this->cha;

this->maxweight = 70 + this->str;

if (this->maxweight < 70 || this->maxweight > 250)

{

this->maxweight = 250;

}

this->weight = 0;

this->maxhp = 0;

this->maxtp = 0;

this->mindam = 0;

this->maxdam = 0;

this->accuracy = 0;

this->evade = 0;

this->armor = 0;

this->maxsp = 0;

UTIL_PTR_LIST_FOREACH(this->inventory, Character_Item, item)

{

this->weight += this->world->eif->Get(item->id)->weight * item->amount;

if (this->weight >= 250)

{

break;

}

}

UTIL_ARRAY_FOREACH_ALL(this->paperdoll, int, 15, i)

{

if (i)

{

EIF_Data *item = this->world->eif->Get(i);

this->weight += item->weight;

this->maxhp += item->hp;

this->maxtp += item->tp;

this->mindam += item->mindam;

this->maxdam += item->maxdam;

this->accuracy += item->accuracy;

this->evade += item->evade;

this->armor += item->armor;

calcstr += item->str;

calcintl += item->intl;

calcwis += item->wis;

calcagi += item->agi;

calccon += item->con;

calccha += item->cha;

}

}

if (this->weight < 0 || this->weight > 250)

{

this->weight = 250;

}

this->maxhp += 10 + calccon*3;

this->maxtp += 10 + calcwis*3;

this->mindam += 1 + calcstr/2;

this->maxdam += 2 + calcstr/2;

this->accuracy += 0 + calcagi/2;

this->evade += 0 + calcagi/2;

this->armor += 0 + calccon/2;

this->maxsp += std::min(20 + this->level*2, 100);

if (this->party)

{

this->party->UpdateHP(this);

}

}

void Character::DropAll(Character *killer)

{

// TODO: This could be more efficient

restart_loop:

UTIL_PTR_LIST_FOREACH(this->inventory, Character_Item, item)

{

if (this->world->eif->Get(item->id)->special == EIF::Lore)

{

continue;

}

Map_Item *map_item = this->player->character->map->AddItem(item->id, item->amount, this->x, this->y, 0);

if (map_item)

{

if (killer)

{

map_item->owner = killer->player->id;

map_item->unprotecttime = Timer::GetTime() + static_cast<double>(this->world->config["ProtectPKDrop"]);

}

else

{

map_item->owner = this->player->id;

map_item->unprotecttime = Timer::GetTime() + static_cast<double>(this->world->config["ProtectDeathDrop"]);

}

PacketBuilder builder(PACKET_ITEM, PACKET_DROP);

builder.AddShort(item->id);

builder.AddThree(item->amount);

builder.AddInt(0);

builder.AddShort(map_item->uid);

builder.AddChar(this->x);

builder.AddChar(this->y);

builder.AddChar(this->weight);

builder.AddChar(this->maxweight);

this->player->client->SendBuilder(builder);

}

this->DelItem(item, item->amount);

goto restart_loop;

}

int i = 0;

UTIL_ARRAY_FOREACH_ALL(this->paperdoll, int, 15, id)

{

if (id == 0 || this->world->eif->Get(id)->special == EIF::Lore || this->world->eif->Get(id)->special == EIF::Cursed)

{

++i;

continue;

}

Map_Item *map_item = this->player->character->map->AddItem(id, 1, this->x, this->y, 0);

if (map_item)

{

if (killer)

{

map_item->owner = killer->player->id;

map_item->unprotecttime = Timer::GetTime() + static_cast<double>(this->world->config["ProtectPKDrop"]);

}

else

{

map_item->owner = this->player->id;

map_item->unprotecttime = Timer::GetTime() + static_cast<double>(this->world->config["ProtectDeathDrop"]);

}

int subloc = 0;

if (i == Ring2 || i == Armlet2 || i == Bracer2)

{

subloc = 1;

}

if (this->player->character->Unequip(id, subloc))

{

PacketBuilder builder(PACKET_PAPERDOLL, PACKET_REMOVE);

builder.AddShort(this->player->id);

builder.AddChar(SLOT_CLOTHES);

builder.AddChar(0); // ?

builder.AddShort(this->world->eif->Get(this->paperdoll[Character::Boots])->dollgraphic);

builder.AddShort(this->world->eif->Get(this->paperdoll[Character::Armor])->dollgraphic);

builder.AddShort(this->world->eif->Get(this->paperdoll[Character::Hat])->dollgraphic);

builder.AddShort(this->world->eif->Get(this->paperdoll[Character::Weapon])->dollgraphic);

builder.AddShort(this->world->eif->Get(this->paperdoll[Character::Shield])->dollgraphic);

builder.AddShort(id);

builder.AddChar(subloc);

builder.AddShort(this->maxhp);

builder.AddShort(this->maxtp);

builder.AddShort(this->str);

builder.AddShort(this->intl);

builder.AddShort(this->wis);

builder.AddShort(this->agi);

builder.AddShort(this->con);

builder.AddShort(this->cha);

builder.AddShort(this->mindam);

builder.AddShort(this->maxdam);

builder.AddShort(this->accuracy);

builder.AddShort(this->evade);

builder.AddShort(this->armor);

this->player->client->SendBuilder(builder);

}

this->player->character->DelItem(id, 1);

PacketBuilder builder(PACKET_ITEM, PACKET_DROP);

builder.AddShort(id);

builder.AddThree(1);

builder.AddInt(0);

builder.AddShort(map_item->uid);

builder.AddChar(this->x);

builder.AddChar(this->y);

builder.AddChar(this->weight);

builder.AddChar(this->maxweight);

this->player->client->SendBuilder(builder);

}

++i;

}

}

void Character::PetTransfer()

{

if(this->has_pet && !this->pet_transfer)

{

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

{

if (this->InRange(*character))

{

this->pet->RemoveFromView(*character);

}

}

erase_first(this->map->npcs, this->pet);

this->pet->Release();

this->has_pet = false;

this->pet_transfer = true;

}

else if(this->pet_transfer)

{

if(pet_transfer)

{

unsigned char index = this->map->GenerateNPCIndex();

if (index > 250)

{

return;

}

this->pet = new NPC(this->map, this->pet->id, this->x, this->y, 1, 1, index, true, true);

this->pet->SetOwner(this);

this->map->npcs.push_back(this->pet);

this->pet->Spawn();

this->has_pet = true;

this->pet_transfer = false;

}

}

}

void Character::Hide()

{

this->hidden = true;

PacketBuilder builder(PACKET_ADMININTERACT, PACKET_REMOVE);

builder.AddShort(this->player->id);

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

{

character->player->client->SendBuilder(builder);

}

}

void Character::Unhide()

{

this->hidden = false;

PacketBuilder builder(PACKET_ADMININTERACT, PACKET_AGREE);

builder.AddShort(this->player->id);

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

{

character->player->client->SendBuilder(builder);

}

}

#define v(x) vars[prefix + #x] = x;

#define vv(x, n) vars[prefix + n] = x;

void Character::FormulaVars(std::tr1::unordered_map<std::string, double> &vars, std::string prefix)

{

v(level) v(exp) v(hp) v(maxhp) v(tp) v(maxtp) v(maxsp)

v(weight) v(maxweight) v(karma) v(mindam) v(maxdam)

v(str) vv(intl, "int") v(wis) v(agi) v(con) v(cha)

v(accuracy) v(evade) v(armor) v(admin)

}

#undef vv

#undef v

void Character::Logout()

{

if (!this->online)

{

if (this->guild)

{

this->guild->Release();

this->guild = 0;

}

return;

}

if (this->trading)

{

PacketBuilder builder(PACKET_TRADE, PACKET_CLOSE);

builder.AddShort(this->id);

this->trade_partner->player->client->SendBuilder(builder);

this->player->client->state = EOClient::Playing;

this->trading = false;

this->trade_inventory.clear();

this->trade_agree = false;

this->trade_partner->player->client->state = EOClient::Playing;

this->trade_partner->trading = false;

this->trade_partner->trade_inventory.clear();

this->trade_agree = false;

this->trade_partner->trade_partner = 0;

this->trade_partner = 0;

}

if (this->party)

{

this->party->Leave(this);

}

if (this->arena)

{

--this->arena->occupants;

}

UTIL_PTR_LIST_FOREACH(this->unregister_npc, NPC, npc)

{

UTIL_PTR_LIST_FOREACH(npc->damagelist, NPC_Opponent, checkopp)

{

if (checkopp->attacker == this)

{

npc->totaldamage -= checkopp->damage;

npc->damagelist.erase(checkopp);

break;

}

}

}

this->online = false;

this->Save();

this->world->Logout(this);

}

void Character::Save()

{

#ifdef DEBUG

Console::Dbg("Saving character '%s' (session lasted %i minutes)", this->name.c_str(), int(std::time(0) - this->login_time) / 60);

#endif // DEBUG

this->world->db.Query("UPDATE `characters` SET `title` = '$', `home` = '$', `partner` = '$', `class` = #, `gender` = #, `race` = #, "

"`hairstyle` = #, `haircolor` = #, `map` = #, `x` = #, `y` = #, `direction` = #, `level` = #, `exp` = #, `hp` = #, `tp` = #, "

"`str` = #, `int` = #, `wis` = #, `agi` = #, `con` = #, `cha` = #, `statpoints` = #, `skillpoints` = #, `karma` = #, `sitting` = #, "

"`bankmax` = #, `goldbank` = #, `usage` = #, `inventory` = '$', `bank` = '$', `paperdoll` = '$', "

"`spells` = '$', `guild` = '$', guild_rank = #, `quest` = '$', `vars` = '$' WHERE `name` = '$'",

this->title.c_str(), this->home.c_str(), this->partner.c_str(), this->clas, this->gender, this->race,

this->hairstyle, this->haircolor, this->mapid, this->x, this->y, this->direction, this->level, this->exp, this->hp, this->tp,

this->str, this->intl, this->wis, this->agi, this->con, this->cha, this->statpoints, this->skillpoints, this->karma, this->sitting,

this->bankmax, this->goldbank, this->Usage(), ItemSerialize(this->inventory).c_str(), ItemSerialize(this->bank).c_str(),

DollSerialize(this->paperdoll).c_str(), "", (this->guild ? this->guild->tag.c_str() : ""), this->guild_rank, "", "", this->name.c_str());

}

Character::~Character()

{

this->Logout();

}

---
Create your own destiny, don't let someone else do it for you.

Search for hide() in that cpp.

And paste it like this;

The Link

Then go to characer.hpp
and place under

void Hide();

void StatSkill();

---
"Pineapples and shit."

Ananas posted: (10th Mar 2010 06:29 am)

Search for hide() in that cpp.

And paste it like this;

The Link

Then go to characer.hpp
and place under

void Hide();

void StatSkill();

Still doesn't work, but ill mess with it later

---
Create your own destiny, don't let someone else do it for you.