Ir para conteúdo
Close

REFORMULAMOS A SEÇÃO DE CLASSIFICADOS! - Crie grátis os seus anúncios de procura e oferta de serviços e produtos relacionados ao OTServ! - Acesse através do nosso menu ou clique aqui e confira já!

robiie123

Membro
  • Total de itens

    37
  • Registro em

  • Última visita

Sobre robiie123

  • Rank
    Artesão

Últimos Visitantes

O bloco dos últimos visitantes está desativado e não está sendo visualizado por outros usuários.

  1. tem uma database compatível com ele?
  2. robiie123

    NPC Npc Missão

    Bom dia galera queria ver o seguinte.. Um npc que teleporta o player para uma sala especial e precisa ser premmy e ter um level minimo para entrar e la dentro o player pode ficar 30 minutos.. depois disso o npc teleporta o player para fora.. e também que ninguém possa entrar enquanto alguém está la dentro. vlw
  3. robiie123

    Sprites Zezenia

    opa, ja atualizei o link com mais coisas bele e os monstro que eu tenho
  4. vlw, tem outros jogos que usam isso.. vai ter quiver basico e quiver mais avançados onde pode carregar mais arrows ou bolts.
  5. robiie123

    Zenza Online

    Novo Servidor Tibia 10.10 Map Full 1º Sistema de Combat Reformulado 2º Char pode Atacar ao mesmo momento em que estiver andando 3º Algumas Magias com Sprints Diferentes 4º Prissão Para Botters 100% 5º Nao terá itens Editados no game ou no site para Venda 6º Sistema de Quiver para Paladinos - no lugar da flecha vai o quiver e dentro poderá colocar até 2 mil flechas. 7º Sistema de Task - Experiencia - Gold - Skill Book 8º Sistema AutoLoot - Personagens poderá optar por usar ou não usar 9º Summons de Monsters - Darão loot e experiencia https://www.facebook.com/ZenzaOnline
  6. robiie123

    Sprites Zezenia

    tem alguns vo atualizar
  7. Este é meu weapow consegue me ajuda? //////////////////////////////////////////////////////////////////////// // OpenTibia - an opensource roleplaying game //////////////////////////////////////////////////////////////////////// // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. //////////////////////////////////////////////////////////////////////// #include "otpch.h" #include <iostream> #include <iomanip> #include "player.h" #include "manager.h" #include "iologindata.h" #include "ioban.h" #include "town.h" #include "house.h" #include "beds.h" #include "mounts.h" #include "quests.h" #include "combat.h" #include "movement.h" #include "weapons.h" #include "creatureevent.h" #include "configmanager.h" #include "game.h" #include "chat.h" extern ConfigManager g_config; extern Game g_game; extern Chat g_chat; extern MoveEvents* g_moveEvents; extern Weapons* g_weapons; extern CreatureEvents* g_creatureEvents; AutoList<Player> Player::autoList; #ifdef __ENABLE_SERVER_DIAGNOSTIC__ uint32_t Player::playerCount = 0; #endif MuteCountMap Player::muteCountMap; Player::Player(const std::string& _name, ProtocolGame* p): Creature(), transferContainer(ITEM_LOCKER), name(_name), nameDescription(_name), client(p) { if(client) p->setPlayer(this); dialogControl.dialogId = 0; dialogControl.pos.x = 0; dialogControl.pos.y = 0; dialogControl.pos.z = 0; pvpBlessing = pzLocked = isConnecting = addAttackSkillPoint = requestedOutfit = mounted = outfitAttributes = sentChat = false; saving = true; lastAttackBlockType = BLOCK_NONE; chaseMode = CHASEMODE_STANDSTILL; fightMode = FIGHTMODE_ATTACK; tradeState = TRADE_NONE; accountManager = MANAGER_NONE; guildLevel = GUILDLEVEL_NONE; vocationId = VOCATION_NONE; promotionLevel = walkTaskEvent = actionTaskEvent = nextStepEvent = bloodHitCount = shieldBlockCount = 0; mailAttempts = idleTime = marriage = blessings = balance = premiumDays = mana = manaMax = manaSpent = 0; soul = guildId = levelPercent = magLevelPercent = magLevel = experience = damageImmunities = rankId = 0; conditionImmunities = conditionSuppressions = groupId = managerNumber2 = town = skullEnd = 0; lastLogin = lastLogout = lastIP = messageTicks = messageBuffer = nextAction = editListId = maxWriteLen = 0; windowTextId = nextExAction = offlineTrainingTime = lastStatsTrainingTime = 0; purchaseCallback = saleCallback = offlineTrainingSkill = marketDepotId = lastDepotId = -1; level = 1; rates[SKILL__MAGLEVEL] = rates[SKILL__LEVEL] = 1.0f; soulMax = 100; capacity = 400.00; stamina = STAMINA_MAX; lastLoad = lastPing = lastPong = lastAttack = lastMail = OTSYS_TIME(); writeItem = NULL; group = NULL; editHouse = NULL; shopOwner = NULL; tradeItem = NULL; tradePartner = NULL; walkTask = NULL; weapon = NULL; bed = NULL; setVocation(0); setParty(NULL); inbox = new Inbox(ITEM_INBOX); inbox->addRef(); depotChange = false; transferContainer.setParent(NULL); for(int32_t i = 0; i < 11; ++i) { inventory[i] = NULL; inventoryAbilities[i] = false; } for(int32_t i = SKILL_FIRST; i <= SKILL_LAST; ++i) { skills[i][SKILL_LEVEL] = 10; skills[i][SKILL_TRIES] = skills[i][SKILL_PERCENT] = 0; rates[i] = 1.0f; } for(int32_t i = SKILL_FIRST; i <= SKILL_LAST; ++i) varSkills[i] = 0; for(int32_t i = STAT_FIRST; i <= STAT_LAST; ++i) varStats[i] = 0; for(int32_t i = LOSS_FIRST; i <= LOSS_LAST; ++i) lossPercent[i] = 100; for(int32_t i = 0; i <= 12; ++i) talkState[i] = false; #ifdef __ENABLE_SERVER_DIAGNOSTIC__ playerCount++; #endif } Player::~Player() { #ifdef __ENABLE_SERVER_DIAGNOSTIC__ playerCount--; #endif for(int32_t i = 0; i < 11; ++i) { if(!inventory[i]) continue; inventory[i]->setParent(NULL); inventory[i]->unRef(); inventory[i] = NULL; inventoryAbilities[i] = false; } setWriteItem(NULL); setNextWalkActionTask(NULL); transferContainer.setParent(NULL); for(DepotLockerMap::iterator it = depotLockerMap.begin(), end = depotLockerMap.end(); it != end; ++it) { it->second->removeInbox(inbox); it->second->unRef(); } inbox->unRef(); } void Player::setVocation(uint32_t id) { vocationId = id; if(!(vocation = Vocations::getInstance()->getVocation(id))) return; Creature::setDropLoot((vocation->getDropLoot() ? LOOT_DROP_FULL : LOOT_DROP_PREVENT)); Creature::setLossSkill(vocation->getLossSkill()); if(client) client->sendBasicData(); soulMax = vocation->getGain(GAIN_SOUL); if(Condition* condition = getCondition(CONDITION_REGENERATION, CONDITIONID_DEFAULT)) { condition->setParam(CONDITIONPARAM_HEALTHGAIN, vocation->getGainAmount(GAIN_HEALTH)); condition->setParam(CONDITIONPARAM_HEALTHTICKS, (vocation->getGainTicks(GAIN_HEALTH) * 1000)); condition->setParam(CONDITIONPARAM_MANAGAIN, vocation->getGainAmount(GAIN_MANA)); condition->setParam(CONDITIONPARAM_MANATICKS, (vocation->getGainTicks(GAIN_MANA) * 1000)); } } void Player::setDropLoot(lootDrop_t _lootDrop) { if(vocation && !vocation->getDropLoot()) _lootDrop = LOOT_DROP_PREVENT; Creature::setDropLoot(_lootDrop); } void Player::setLossSkill(bool _skillLoss) { if(vocation && !vocation->getLossSkill()) _skillLoss = false; Creature::setLossSkill(_skillLoss); } bool Player::isPushable() const { return accountManager == MANAGER_NONE && !hasFlag(PlayerFlag_CannotBePushed) && Creature::isPushable(); } std::string Player::getDescription(int32_t lookDistance) const { std::stringstream s; if(lookDistance == -1) { s << "yourself."; if(hasFlag(PlayerFlag_ShowGroupNameInsteadOfVocation)) s << " You are " << group->getName(); else if(vocationId != VOCATION_NONE) s << " You are " << vocation->getDescription(); else s << " You have no vocation"; } else { s << nameDescription; if(!hasCustomFlag(PlayerCustomFlag_HideLevel)) s << " (Level " << level << ")"; s << ". " << (sex % 2 ? "He" : "She"); if(hasFlag(PlayerFlag_ShowGroupNameInsteadOfVocation)) s << " is " << group->getName(); else if(vocationId != VOCATION_NONE) s << " is " << vocation->getDescription(); else s << " has no vocation"; } std::string tmp; if(marriage && IOLoginData::getInstance()->getNameByGuid(marriage, tmp)) { s << ", "; if(vocationId == VOCATION_NONE) { if(lookDistance == -1) s << "and you are"; else s << "and is"; s << " "; } s << (sex % 2 ? "husband" : "wife") << " of " << tmp; } s << "."; if(guildId) { if(lookDistance == -1) s << " You are "; else s << " " << (sex % 2 ? "He" : "She") << " is "; s << (rankName.empty() ? "a member" : rankName)<< " of the " << guildName; if(!guildNick.empty()) s << " (" << guildNick << ")"; s << "."; } s << getSpecialDescription(); return s.str(); } Item* Player::getInventoryItem(slots_t slot) const { if(slot > SLOT_PRE_FIRST && slot < SLOT_LAST) return inventory[slot]; if(slot == SLOT_HAND) return inventory[SLOT_LEFT] ? inventory[SLOT_LEFT] : inventory[SLOT_RIGHT]; return NULL; } Item* Player::getEquippedItem(slots_t slot) const { Item* item = getInventoryItem(slot); if(!item) return NULL; switch(slot) { case SLOT_LEFT: case SLOT_RIGHT: if(item->getWieldPosition() == SLOT_HAND) return item; default: break; } return item->getWieldPosition() == slot ? item : NULL; } void Player::setConditionSuppressions(uint32_t conditions, bool remove) { if(remove) conditionSuppressions &= ~conditions; else conditionSuppressions |= conditions; } Item* Player::getWeapon(bool ignoreAmmo) { if(!ignoreAmmo && weapon) return weapon; Item* item = NULL; for(int32_t slot = SLOT_RIGHT; slot <= SLOT_LEFT; ++slot) { if(!(item = getEquippedItem((slots_t)slot)) || item->getWeaponType() != WEAPON_DIST) continue; if(!ignoreAmmo && item->getAmmoType() != AMMO_NONE) { Item* ammoItem = getInventoryItem(SLOT_AMMO); if(ammoItem && ammoItem->getAmmoType() == item->getAmmoType()) { if(g_weapons->getWeapon(ammoItem)) return ammoItem; } } else if(g_weapons->getWeapon(item)) return item; } return NULL; } ItemVector Player::getWeapons() const { Item* item = NULL; ItemVector weapons; for(int32_t slot = SLOT_RIGHT; slot <= SLOT_LEFT; ++slot) { if(!(item = getEquippedItem((slots_t)slot))) continue; switch(item->getWeaponType()) { case WEAPON_SHIELD: break; case WEAPON_DIST: // By Swatt' { if(item->getAmmoType() != AMMO_NONE) { Item* weaponItem = item; Item* ammoItem = getInventoryItem(SLOT_AMMO); if(ammoItem) { if(ammoItem->getAmmoType() == item->getAmmoType()) { //g_game.addMagicEffect(getPosition(), MAGIC_EFFECT_SOUND_GREEN); item = ammoItem; } else if(ammoItem->isContainer()) { //g_game.addMagicEffect(getPosition(), MAGIC_EFFECT_SOUND_YELLOW); if(Container* container = ammoItem->getContainer()) { for(int32_t i = 0; i < (int32_t)container->size(); ++i) { Item* subitem = container->getItem(i); if(!subitem){/*g_game.addMagicEffect(getPosition(), MAGIC_EFFECT_SMALLCLOUDS)*/; break;} if(weaponItem->getAmmoType() == subitem->getAmmoType()) { //std::clog << "[CERTO]: WeaponID:" << weaponItem->getID() << "/ AmmoID:" << subitem->getID() << "/ Slot:" << i << std::endl; //g_game.addMagicEffect(getPosition(), MAGIC_EFFECT_SOUND_BLUE); item = subitem; break; } else { //std::clog << "[ERRO]: WeaponID:" << weaponItem->getID() << "/ AmmoID:" << subitem->getID() << "/ Slot:" << i << std::endl; //g_game.addMagicEffect(getPosition(), MAGIC_EFFECT_SOUND_PURPLE); item = NULL; } } } } else { //g_game.addMagicEffect(getPosition(), MAGIC_EFFECT_SOUND_WHITE); break; } } else { //g_game.addMagicEffect(getPosition(), MAGIC_EFFECT_SOUND_RED); break; } } } default: { if(g_weapons->getWeapon(item)) weapons.push_back(item); break; } } } return weapons; } void Player::updateWeapon() { ItemVector weapons = getWeapons(); if(weapons.empty()) weapon = NULL; else if(!weapon || weapons.size() == 1 || weapons[1] == weapon) weapon = weapons[0]; else if(weapons[0] == weapon) weapon = weapons[1]; else weapon = NULL; } WeaponType_t Player::getWeaponType() { if(weapon) return weapon->getWeaponType(); return WEAPON_NONE; } int32_t Player::getWeaponSkill(const Item* item) const { if(!item) return getSkill(SKILL_FIST, SKILL_LEVEL); switch(item->getWeaponType()) { case WEAPON_SWORD: return getSkill(SKILL_SWORD, SKILL_LEVEL); case WEAPON_CLUB: return getSkill(SKILL_CLUB, SKILL_LEVEL); case WEAPON_AXE: return getSkill(SKILL_AXE, SKILL_LEVEL); case WEAPON_FIST: return getSkill(SKILL_FIST, SKILL_LEVEL); case WEAPON_DIST: case WEAPON_AMMO: return getSkill(SKILL_DIST, SKILL_LEVEL); default: break; } return 0; } int32_t Player::getArmor() const { int32_t i = SLOT_FIRST, armor = 0; for(; i < SLOT_LAST; ++i) { if(Item* item = getInventoryItem((slots_t)i)) armor += item->getArmor(); } if(vocation->getMultiplier(MULTIPLIER_ARMOR) != 1.0) return int32_t(armor * vocation->getMultiplier(MULTIPLIER_ARMOR)); return armor; } void Player::getShieldAndWeapon(const Item* &_shield, const Item* &_weapon) const { _shield = NULL; Item* item = NULL; for(uint32_t slot = SLOT_RIGHT; slot <= SLOT_LEFT; ++slot) { if(!(item = getInventoryItem((slots_t)slot)) || item->getWeaponType() != WEAPON_SHIELD) continue; if(!_shield || (_shield && item->getDefense() > _shield->getDefense())) _shield = item; } _weapon = weapon; } int32_t Player::getDefense() const { int32_t baseDefense = 5, defenseValue = 0, defenseSkill = 0, extraDefense = 0; float defenseFactor = getDefenseFactor(); const Item *_weapon = NULL, *_shield = NULL; getShieldAndWeapon(_shield, _weapon); if(_weapon) { extraDefense = _weapon->getExtraDefense(); defenseValue = baseDefense + _weapon->getDefense(); defenseSkill = getWeaponSkill(_weapon); } if(_shield && _shield->getDefense() > defenseValue) { if(_shield->getExtraDefense() > extraDefense) extraDefense = _shield->getExtraDefense(); defenseValue = baseDefense + _shield->getDefense(); defenseSkill = getSkill(SKILL_SHIELD, SKILL_LEVEL); } if(!defenseSkill) return 0; defenseValue += extraDefense; if(vocation->getMultiplier(MULTIPLIER_DEFENSE) != 1.0) defenseValue = int32_t(defenseValue * vocation->getMultiplier(MULTIPLIER_DEFENSE)); return ((int32_t)std::ceil(((float)(defenseSkill * (defenseValue * 0.015)) + (defenseValue * 0.1)) * defenseFactor)); } float Player::getAttackFactor() const { switch(fightMode) { case FIGHTMODE_BALANCED: return 1.2f; case FIGHTMODE_DEFENSE: return 2.0f; case FIGHTMODE_ATTACK: default: break; } return 1.0f; } float Player::getDefenseFactor() const { switch(fightMode) { case FIGHTMODE_BALANCED: return 1.2f; case FIGHTMODE_DEFENSE: { if((OTSYS_TIME() - lastAttack) < getAttackSpeed()) //attacking will cause us to get into normal defense return 1.0f; return 2.0f; } case FIGHTMODE_ATTACK: default: break; } return 1.0f; } void Player::sendIcons() const { if(!client) return; uint32_t icons = ICON_NONE; for(ConditionList::const_iterator it = conditions.begin(); it != conditions.end(); ++it) { if(!isSuppress((*it)->getType())) icons |= (*it)->getIcons(); } if(getZone() == ZONE_PROTECTION) { icons |= ICON_PZ; // Don't show ICON_SWORDS if player is in protection zone. if(hasBitSet(ICON_SWORDS, icons)) icons &= ~ICON_SWORDS; } if(pzLocked) icons |= ICON_PZBLOCK; if(!getCondition(CONDITION_REGENERATION, CONDITIONID_DEFAULT)) icons |= ICON_HUNGRY; // Tibia client debugs with 10 or more icons // so let's prevent that from happening. std::bitset<20> icon_bitset((uint64_t)icons); for(size_t i = 0, size = icon_bitset.size(); i < size; ++i) { if(icon_bitset.count() < 10) break; if(icon_bitset[i]) icon_bitset.reset(i); } client->sendIcons(icon_bitset.to_ulong()); } void Player::updateInventoryWeight() { inventoryWeight = 0.00; if(hasFlag(PlayerFlag_HasInfiniteCapacity) || !g_config.getBool(ConfigManager::USE_CAPACITY)) return; for(int32_t i = SLOT_FIRST; i < SLOT_LAST; ++i) { if(Item* item = getInventoryItem((slots_t)i)) inventoryWeight += item->getWeight(); } } void Player::updateInventoryGoods(uint32_t itemId) { if(Item::items[itemId].worth) { sendGoods(); return; } for(ShopInfoList::iterator it = shopOffer.begin(); it != shopOffer.end(); ++it) { if(it->itemId != itemId) continue; sendGoods(); break; } } int32_t Player::getPlayerInfo(playerinfo_t playerinfo) const { switch(playerinfo) { case PLAYERINFO_LEVEL: return level; case PLAYERINFO_LEVELPERCENT: return levelPercent; case PLAYERINFO_MAGICLEVEL: return std::max((int32_t)0, ((int32_t)magLevel + varStats[STAT_MAGICLEVEL])); case PLAYERINFO_MAGICLEVELPERCENT: return magLevelPercent; case PLAYERINFO_HEALTH: return health; case PLAYERINFO_MAXHEALTH: return std::max((int32_t)1, ((int32_t)healthMax + varStats[STAT_MAXHEALTH])); case PLAYERINFO_MANA: return mana; case PLAYERINFO_MAXMANA: return std::max((int32_t)0, ((int32_t)manaMax + varStats[STAT_MAXMANA])); case PLAYERINFO_SOUL: return std::max((int32_t)0, ((int32_t)soul + varStats[STAT_SOUL])); default: break; } return 0; } int32_t Player::getSkill(skills_t skilltype, skillsid_t skillinfo) const { int32_t ret = skills[skilltype][skillinfo]; if(skillinfo == SKILL_LEVEL) ret += varSkills[skilltype]; return std::max((int32_t)0, ret); } void Player::addSkillAdvance(skills_t skill, uint64_t count, bool useMultiplier/* = true*/) { if(!count) return; //player has reached max skill uint64_t currReqTries = vocation->getReqSkillTries(skill, skills[skill][SKILL_LEVEL]), nextReqTries = vocation->getReqSkillTries(skill, skills[skill][SKILL_LEVEL] + 1); if(currReqTries > nextReqTries) return; if(useMultiplier) count = uint64_t((double)count * rates[skill] * g_config.getDouble(ConfigManager::RATE_SKILL)); std::stringstream s; while(skills[skill][SKILL_TRIES] + count >= nextReqTries) { count -= nextReqTries - skills[skill][SKILL_TRIES]; skills[skill][SKILL_TRIES] = skills[skill][SKILL_PERCENT] = 0; skills[skill][SKILL_LEVEL]++; s.str(""); s << "You advanced to " << getSkillName(skill) << " level " << skills[skill][SKILL_LEVEL] << "."; sendTextMessage(MSG_EVENT_ADVANCE, s.str().c_str()); CreatureEventList advanceEvents = getCreatureEvents(CREATURE_EVENT_ADVANCE); for(CreatureEventList::iterator it = advanceEvents.begin(); it != advanceEvents.end(); ++it) (*it)->executeAdvance(this, skill, (skills[skill][SKILL_LEVEL] - 1), skills[skill][SKILL_LEVEL]); currReqTries = nextReqTries; nextReqTries = vocation->getReqSkillTries(skill, skills[skill][SKILL_LEVEL] + 1); if(currReqTries > nextReqTries) { count = 0; break; } } if(count) skills[skill][SKILL_TRIES] += count; //update percent uint16_t newPercent = Player::getPercentLevel(skills[skill][SKILL_TRIES], nextReqTries); if(skills[skill][SKILL_PERCENT] != newPercent) { skills[skill][SKILL_PERCENT] = newPercent; sendSkills(); } else if(!s.str().empty()) sendSkills(); } void Player::setVarStats(stats_t stat, int32_t modifier) { varStats[stat] += modifier; switch(stat) { case STAT_MAXHEALTH: { if(getHealth() > getMaxHealth()) Creature::changeHealth(getMaxHealth() - getHealth()); else g_game.addCreatureHealth(this); break; } case STAT_MAXMANA: { if(getMana() > getMaxMana()) Creature::changeMana(getMaxMana() - getMana()); break; } default: break; } } int32_t Player::getDefaultStats(stats_t stat) { switch(stat) { case STAT_MAGICLEVEL: return getMagicLevel() - getVarStats(STAT_MAGICLEVEL); case STAT_MAXHEALTH: return getMaxHealth() - getVarStats(STAT_MAXHEALTH); case STAT_MAXMANA: return getMaxMana() - getVarStats(STAT_MAXMANA); case STAT_SOUL: return getSoul() - getVarStats(STAT_SOUL); default: break; } return 0; } Container* Player::getContainer(uint32_t cid) { for(ContainerVector::iterator it = containerVec.begin(); it != containerVec.end(); ++it) { if(it->first == cid) return it->second; } return NULL; } int32_t Player::getContainerID(const Container* container) const { for(ContainerVector::const_iterator cl = containerVec.begin(); cl != containerVec.end(); ++cl) { if(cl->second == container) return cl->first; } return -1; } void Player::addContainer(uint32_t cid, Container* container) { #ifdef __DEBUG__ std::clog << getName() << ", addContainer: " << (int32_t)cid << std::endl; #endif if(cid > 0xF) return; for(ContainerVector::iterator cl = containerVec.begin(); cl != containerVec.end(); ++cl) { if(cl->first == cid) { cl->second = container; return; } } containerVec.push_back(std::make_pair(cid, container)); } void Player::closeContainer(uint32_t cid) { for(ContainerVector::iterator cl = containerVec.begin(); cl != containerVec.end(); ++cl) { if(cl->first == cid) { containerVec.erase(cl); break; } } #ifdef __DEBUG__ std::clog << getName() << ", closeContainer: " << (int32_t)cid << std::endl; #endif } bool Player::canOpenCorpse(uint32_t ownerId) { return guid == ownerId || (party && party->canOpenCorpse(ownerId)) || hasCustomFlag(PlayerCustomFlag_GamemasterPrivileges); } uint16_t Player::getLookCorpse() const { return (sex % 2) ? ITEM_MALE_CORPSE : ITEM_FEMALE_CORPSE; } void Player::dropLoot(Container* corpse) { if(!corpse || lootDrop != LOOT_DROP_FULL) return; uint32_t loss = lossPercent[LOSS_CONTAINERS], start = g_config.getNumber( ConfigManager::BLESS_REDUCTION_BASE), bless = getBlessings(); while(bless > 0 && loss > 0) { loss -= start; start -= g_config.getNumber(ConfigManager::BLESS_REDUCTION_DECREMENT); --bless; } uint32_t itemLoss = (uint32_t)std::floor((5. + loss) * lossPercent[LOSS_ITEMS] / 1000.); for(int32_t i = SLOT_FIRST; i < SLOT_LAST; ++i) { Item* item = inventory[i]; if(!item) continue; uint32_t tmp = random_range(1, 100); if(skull > SKULL_WHITE || (item->getContainer() && tmp < loss) || (!item->getContainer() && tmp < itemLoss)) { g_game.internalMoveItem(NULL, this, corpse, INDEX_WHEREEVER, item, item->getItemCount(), 0); sendRemoveInventoryItem((slots_t)i, inventory[(slots_t)i]); } } } bool Player::setStorage(const std::string& key, const std::string& value) { uint32_t numericKey = atol(key.c_str()); if(!IS_IN_KEYRANGE(numericKey, RESERVED_RANGE) || IS_IN_KEYRANGE(numericKey, MOUNTS_RANGE)) { if(!Creature::setStorage(key, value)) return false; if(Quests::getInstance()->isQuestStorage(key, value, true)) onUpdateQuest(); return true; } if(IS_IN_KEYRANGE(numericKey, OUTFITS_RANGE)) { uint32_t lookType = atoi(value.c_str()) >> 16, addons = atoi(value.c_str()) & 0xFF; if(addons < 4) { Outfit outfit; if(Outfits::getInstance()->getOutfit(lookType, outfit)) return addOutfit(outfit.outfitId, addons); } else std::clog << "[Warning - Player::setStorage] Invalid addons value key: " << key << ", value: " << value << " for player: " << getName() << std::endl; } else if(IS_IN_KEYRANGE(numericKey, OUTFITSID_RANGE)) { uint32_t outfitId = atoi(value.c_str()) >> 16, addons = atoi(value.c_str()) & 0xFF; if(addons < 4) return addOutfit(outfitId, addons); else std::clog << "[Warning - Player::setStorage] Invalid addons value key: " << key << ", value: " << value << " for player: " << getName() << std::endl; } else std::clog << "[Warning - Player::setStorage] Unknown reserved key: " << key << " for player: " << getName() << std::endl; return false; } void Player::eraseStorage(const std::string& key) { Creature::eraseStorage(key); if(IS_IN_KEYRANGE(atol(key.c_str()), RESERVED_RANGE)) std::clog << "[Warning - Player::eraseStorage] Unknown reserved key: " << key << " for player: " << name << std::endl; } bool Player::canSee(const Position& pos) const { if(client) return client->canSee(pos); return false; } bool Player::canSeeCreature(const Creature* creature) const { if(creature == this) return true; if(const Player* player = creature->getPlayer()) return !player->isGhost() || getGhostAccess() >= player->getGhostAccess(); return !creature->isInvisible() || canSeeInvisibility(); } bool Player::canWalkthrough(const Creature* creature) const { if(creature == this || hasFlag(PlayerFlag_CanPassThroughAllCreatures) || creature->isWalkable() || std::find(forceWalkthrough.begin(), forceWalkthrough.end(), creature->getID()) != forceWalkthrough.end() || (creature->getMaster() && creature->getMaster() != this && canWalkthrough(creature->getMaster()))) return true; const Player* player = creature->getPlayer(); if(!player) return false; if(((g_game.getWorldType() == WORLDTYPE_OPTIONAL && !player->isEnemy(this, true) && !player->isProtected()) || player->getTile()->hasFlag(TILESTATE_PROTECTIONZONE) || player->isProtected()) && player->getTile()->ground && Item::items[player->getTile()->ground->getID()].walkStack && (!player->hasCustomFlag(PlayerCustomFlag_GamemasterPrivileges) || player->getAccess() <= getAccess())) return true; return (player->isGhost() && getGhostAccess() < player->getGhostAccess()) || (isGhost() && getGhostAccess() > player->getGhostAccess()); } void Player::setWalkthrough(const Creature* creature, bool walkthrough) { std::vector<uint32_t>::iterator it = std::find(forceWalkthrough.begin(), forceWalkthrough.end(), creature->getID()); bool update = false; if(walkthrough && it == forceWalkthrough.end()) { forceWalkthrough.push_back(creature->getID()); update = true; } else if(!walkthrough && it != forceWalkthrough.end()) { forceWalkthrough.erase(it); update = true; } if(update) sendCreatureWalkthrough(creature, !walkthrough ? canWalkthrough(creature) : walkthrough); } DepotChest* Player::getDepotChest(uint32_t depotId, bool autoCreate) { DepotMap::iterator it = depotChests.find(depotId); if(it != depotChests.end()) return it->second; if(!autoCreate) return NULL; DepotChest* depotChest = new DepotChest(ITEM_DEPOT); depotChest->addRef(); depotChest->setMaxDepotLimit((group != NULL ? group->getDepotLimit(isPremium()) : 1000)); depotChests[depotId] = depotChest; return depotChest; } DepotLocker* Player::getDepotLocker(uint32_t depotId) { DepotLockerMap::iterator it = depotLockerMap.find(depotId); if(it != depotLockerMap.end()) { inbox->setParent(it->second); return it->second; } DepotLocker* depotLocker = new DepotLocker(ITEM_LOCKER); depotLocker->setDepotId(depotId); depotLocker->__internalAddThing(Item::CreateItem(ITEM_MARKET)); depotLocker->__internalAddThing(inbox); depotLocker->__internalAddThing(getDepotChest(depotId, true)); depotLockerMap[depotId] = depotLocker; return depotLocker; } void Player::sendCancelMessage(ReturnValue message) const { switch(message) { case RET_DESTINATIONOUTOFREACH: sendCancel("Destination is out of reach."); break; case RET_NOTMOVABLE: sendCancel("You cannot move this object."); break; case RET_DROPTWOHANDEDITEM: sendCancel("Drop the double-handed object first."); break; case RET_BOTHHANDSNEEDTOBEFREE: sendCancel("Both hands need to be free."); break; case RET_CANNOTBEDRESSED: sendCancel("You cannot dress this object there."); break; case RET_PUTTHISOBJECTINYOURHAND: sendCancel("Put this object in your hand."); break; case RET_PUTTHISOBJECTINBOTHHANDS: sendCancel("Put this object in both hands."); break; case RET_CANONLYUSEONEWEAPON: sendCancel("You may use only one weapon."); break; case RET_TOOFARAWAY: sendCancel("Too far away."); break; case RET_FIRSTGODOWNSTAIRS: sendCancel("First go downstairs."); break; case RET_FIRSTGOUPSTAIRS: sendCancel("First go upstairs."); break; case RET_NOTENOUGHCAPACITY: sendCancel("This object is too heavy for you to carry."); break; case RET_CONTAINERNOTENOUGHROOM: sendCancel("You cannot put more objects in this container."); break; case RET_NEEDEXCHANGE: case RET_NOTENOUGHROOM: sendCancel("There is not enough room."); break; case RET_CANNOTPICKUP: sendCancel("You cannot take this object."); break; case RET_CANNOTTHROW: sendCancel("You cannot throw there."); break; case RET_THEREISNOWAY: sendCancel("There is no way."); break; case RET_THISISIMPOSSIBLE: sendCancel("This is impossible."); break; case RET_PLAYERISPZLOCKED: sendCancel("You cannot enter a protection zone after attacking another player."); break; case RET_PLAYERISNOTINVITED: sendCancel("You are not invited."); break; case RET_CREATUREDOESNOTEXIST: sendCancel("Creature does not exist."); break; case RET_DEPOTISFULL: sendCancel("Your depot is full. Remove surplus items before storing new ones."); break; case RET_CANNOTUSETHISOBJECT: sendCancel("You cannot use this object."); break; case RET_PLAYERWITHTHISNAMEISNOTONLINE: sendCancel("A player with this name is not online."); break; case RET_NOTREQUIREDLEVELTOUSERUNE: sendCancel("You do not have the required magic level to use this rune."); break; case RET_YOUAREALREADYTRADING: sendCancel("You are already trading. Finish this trade first."); break; case RET_THISPLAYERISALREADYTRADING: sendCancel("This person is already trading."); break; case RET_YOUMAYNOTLOGOUTDURINGAFIGHT: sendCancel("You may not logout during or immediately after a fight."); break; case RET_DIRECTPLAYERSHOOT: sendCancel("You are not allowed to shoot directly on players."); break; case RET_NOTENOUGHLEVEL: sendCancel("You do not have enough level."); break; case RET_NOTENOUGHMAGICLEVEL: sendCancel("You do not have enough magic level."); break; case RET_NOTENOUGHMANA: sendCancel("You do not have enough mana."); break; case RET_NOTENOUGHSOUL: sendCancel("You do not have enough soul."); break; case RET_YOUAREEXHAUSTED: sendCancel("You are exhausted."); break; case RET_CANONLYUSETHISRUNEONCREATURES: sendCancel("You can only use this rune on creatures."); break; case RET_PLAYERISNOTREACHABLE: sendCancel("Player is not reachable."); break; case RET_CREATUREISNOTREACHABLE: sendCancel("Creature is not reachable."); break; case RET_ACTIONNOTPERMITTEDINPROTECTIONZONE: sendCancel("This action is not permitted in a protection zone."); break; case RET_YOUMAYNOTATTACKTHISPLAYER: sendCancel("You may not attack this player."); break; case RET_YOUMAYNOTATTACKTHISCREATURE: sendCancel("You may not attack this creature."); break; case RET_YOUMAYNOTATTACKAPERSONINPROTECTIONZONE: sendCancel("You may not attack a person in a protection zone."); break; case RET_YOUMAYNOTATTACKAPERSONWHILEINPROTECTIONZONE: sendCancel("You may not attack a person while you are in a protection zone."); break; case RET_YOUCANONLYUSEITONCREATURES: sendCancel("You can only use it on creatures."); break; case RET_TURNSECUREMODETOATTACKUNMARKEDPLAYERS: sendCancel("Turn secure mode off if you really want to attack unmarked players."); break; case RET_YOUNEEDPREMIUMACCOUNT: sendCancel("You need a premium account."); break; case RET_YOUNEEDTOLEARNTHISSPELL: sendCancel("You need to learn this spell first."); break; case RET_YOURVOCATIONCANNOTUSETHISSPELL: sendCancel("Your vocation cannot use this spell."); break; case RET_YOUNEEDAWEAPONTOUSETHISSPELL: sendCancel("You need to equip a weapon to use this spell."); break; case RET_PLAYERISPZLOCKEDLEAVEPVPZONE: sendCancel("You cannot leave a pvp zone after attacking another player."); break; case RET_PLAYERISPZLOCKEDENTERPVPZONE: sendCancel("You cannot enter a pvp zone after attacking another player."); break; case RET_ACTIONNOTPERMITTEDINANOPVPZONE: sendCancel("This action is not permitted in a safe zone."); break; case RET_YOUCANNOTLOGOUTHERE: sendCancel("You cannot logout here."); break; case RET_YOUNEEDAMAGICITEMTOCASTSPELL: sendCancel("You need a magic item to cast this spell."); break; case RET_CANNOTCONJUREITEMHERE: sendCancel("You cannot conjure items here."); break; case RET_NAMEISTOOAMBIGUOUS: sendCancel("Name is too ambiguous."); break; case RET_CANONLYUSEONESHIELD: sendCancel("You may use only one shield."); break; case RET_YOUARENOTTHEOWNER: sendCancel("You are not the owner."); break; case RET_YOUMAYNOTCASTAREAONBLACKSKULL: sendCancel("You may not cast area spells while you have a black skull."); break; case RET_TILEISFULL: sendCancel("You cannot add more items on this tile."); break; case RET_NOTENOUGHSKILL: sendCancel("You do not have enough skill."); break; case RET_NOTPOSSIBLE: sendCancel("Sorry, not possible."); break; case RET_YOUMAYNOTATTACKIMMEDIATELYAFTERLOGGINGIN: sendCancel("You may not attack immediately after logging in."); break; case RET_YOUCANONLYTRADEUPTOX: { std::stringstream s; s << "You can only trade up to " << g_config.getNumber(ConfigManager::TRADE_LIMIT) << " items at a time."; sendCancel(s.str()); } break; default: break; } } void Player::sendStats() { if(client) { client->sendStats(); lastStatsTrainingTime = getOfflineTrainingTime() / 60 / 1000; } } Item* Player::getWriteItem(uint32_t& _windowTextId, uint16_t& _maxWriteLen) { _windowTextId = windowTextId; _maxWriteLen = maxWriteLen; return writeItem; } void Player::setWriteItem(Item* item, uint16_t _maxLen/* = 0*/) { windowTextId++; if(writeItem) writeItem->unRef(); if(item) { writeItem = item; maxWriteLen = _maxLen; writeItem->addRef(); } else { writeItem = NULL; maxWriteLen = 0; } } House* Player::getEditHouse(uint32_t& _windowTextId, uint32_t& _listId) { _windowTextId = windowTextId; _listId = editListId; return editHouse; } void Player::setEditHouse(House* house, uint32_t listId/* = 0*/) { windowTextId++; editHouse = house; editListId = listId; } void Player::sendHouseWindow(House* house, uint32_t listId) const { if(!client) return; std::string text; if(house->getAccessList(listId, text)) client->sendHouseWindow(windowTextId, house, listId, text); } void Player::sendCreatureChangeVisible(const Creature* creature, Visible_t visible) { if(!client) return; const Player* player = creature->getPlayer(); if(player == this || (player && (visible < VISIBLE_GHOST_APPEAR || getGhostAccess() >= player->getGhostAccess())) || (!player && canSeeInvisibility())) sendCreatureChangeOutfit(creature, creature->getCurrentOutfit()); else if(visible == VISIBLE_DISAPPEAR || visible == VISIBLE_GHOST_DISAPPEAR) sendCreatureDisappear(creature, creature->getTile()->getClientIndexOfThing(this, creature)); else sendCreatureAppear(creature); } void Player::sendAddContainerItem(const Container* container, const Item* item) { if(!client) return; for(ContainerVector::const_iterator cl = containerVec.begin(); cl != containerVec.end(); ++cl) { if(cl->second == container) client->sendAddContainerItem(cl->first, item); } } void Player::sendUpdateContainerItem(const Container* container, uint8_t slot, const Item*, const Item* newItem) { if(!client) return; for(ContainerVector::const_iterator cl = containerVec.begin(); cl != containerVec.end(); ++cl) { if(cl->second == container) client->sendUpdateContainerItem(cl->first, slot, newItem); } } void Player::sendRemoveContainerItem(const Container* container, uint8_t slot, const Item* lastItem) { if(!client) return; for(ContainerVector::const_iterator cl = containerVec.begin(); cl != containerVec.end(); ++cl) { if(cl->second == container) client->sendRemoveContainerItem(cl->first, slot, lastItem); } } void Player::onUpdateTileItem(const Tile* tile, const Position& pos, const Item* oldItem, const ItemType& oldType, const Item* newItem, const ItemType& newType) { Creature::onUpdateTileItem(tile, pos, oldItem, oldType, newItem, newType); if(oldItem != newItem) onRemoveTileItem(tile, pos, oldType, oldItem); if(tradeState != TRADE_TRANSFER && tradeItem && oldItem == tradeItem) g_game.internalCloseTrade(this); } void Player::onRemoveTileItem(const Tile* tile, const Position& pos, const ItemType& iType, const Item* item) { Creature::onRemoveTileItem(tile, pos, iType, item); if(tradeState == TRADE_TRANSFER) return; checkTradeState(item); if(tradeItem) { const Container* container = item->getContainer(); if(container && container->isHoldingItem(tradeItem)) g_game.internalCloseTrade(this); } } void Player::onCreatureAppear(const Creature* creature) { Creature::onCreatureAppear(creature); if(creature != this) return; Item* item = NULL; for(int32_t slot = SLOT_FIRST; slot < SLOT_LAST; ++slot) { if(!(item = getInventoryItem((slots_t)slot))) continue; item->__startDecaying(); g_moveEvents->onPlayerEquip(this, item, (slots_t)slot, false); } updateWeapon(); if(BedItem* _bed = Beds::getInstance()->getBedBySleeper(guid)) _bed->wakeUp(); Outfit outfit; if(Outfits::getInstance()->getOutfit(defaultOutfit.lookType, outfit)) outfitAttributes = Outfits::getInstance()->addAttributes(getID(), outfit.outfitId, sex, defaultOutfit.lookAddons); if(lastLogout && stamina < STAMINA_MAX) { int64_t ticks = (int64_t)time(NULL) - lastLogout - 600; if(ticks > 0) { ticks = (int64_t)((double)(ticks * 1000) / g_config.getDouble(ConfigManager::RATE_STAMINA_GAIN)); int64_t premium = g_config.getNumber(ConfigManager::STAMINA_LIMIT_TOP) * STAMINA_MULTIPLIER, period = ticks; if((int64_t)stamina <= premium) { period += stamina; if(period > premium) period -= premium; else period = 0; useStamina(ticks - period); } if(period > 0) { ticks = (int64_t)((g_config.getDouble(ConfigManager::RATE_STAMINA_GAIN) * period) / g_config.getDouble(ConfigManager::RATE_STAMINA_THRESHOLD)); if(stamina + ticks > STAMINA_MAX) ticks = STAMINA_MAX - stamina; useStamina(ticks); } sendStats(); } } int32_t offlineTime; if(getLastLogout()) offlineTime = std::min((int32_t)(time(NULL) - getLastLogout()), 86400 * 21); else offlineTime = 0; if(offlineTrainingSkill != SKILL_NONE) { int32_t trainingTime = std::max(0, std::min(offlineTime, std::min(43200, getOfflineTrainingTime() / 1000))); if(offlineTime >= 600) { removeOfflineTrainingTime(trainingTime * 1000); int32_t remainder = offlineTime - trainingTime; if(remainder > 0) addOfflineTrainingTime(remainder * 1000); if(trainingTime >= 60) { std::ostringstream ss; ss << "During your absence you trained for "; int32_t hours = trainingTime / 3600; if(hours > 1) ss << hours << " hours"; else if(hours == 1) ss << "1 hour"; int32_t minutes = (trainingTime % 3600) / 60; if(minutes != 0) { if(hours != 0) ss << " and "; if(minutes > 1) ss << minutes << " minutes"; else ss << "1 minute"; } ss << "."; sendTextMessage(MSG_EVENT_ADVANCE, ss.str()); Vocation* voc = getVocation(); if(!isPromoted(promotionLevel + 1)) // maybe a configurable?... { int32_t vocId = Vocations::getInstance()->getPromotedVocation(voc->getId()); if(vocId > 0) { if(Vocation* tmp = Vocations::getInstance()->getVocation(vocId)) voc = tmp; } } if(offlineTrainingSkill == SKILL_CLUB || offlineTrainingSkill == SKILL_SWORD || offlineTrainingSkill == SKILL_AXE) { float modifier = voc->getAttackSpeed() / 1000.f; addOfflineTrainingTries((skills_t)offlineTrainingSkill, (trainingTime / modifier) / 2); } else if(offlineTrainingSkill == SKILL_DIST) { float modifier = voc->getAttackSpeed() / 1000.f; addOfflineTrainingTries((skills_t)offlineTrainingSkill, (trainingTime / modifier) / 4); } else if(offlineTrainingSkill == SKILL__MAGLEVEL) { int32_t gainTicks = voc->getGainTicks(GAIN_MANA) << 1; if(!gainTicks) gainTicks = 1; addOfflineTrainingTries(SKILL__MAGLEVEL, (int32_t)((float) trainingTime * ((float) voc->getGainAmount(GAIN_MANA) / (float) gainTicks))); } if(addOfflineTrainingTries(SKILL_SHIELD, trainingTime / 4)) sendSkills(); } sendStats(); } else sendTextMessage(MSG_EVENT_ADVANCE, "You must be logged out for more than 10 minutes to start offline training."); offlineTrainingSkill = SKILL_NONE; } else { uint16_t oldMinutes = getOfflineTrainingTime() / 60 / 1000; addOfflineTrainingTime(offlineTime * 1000); uint16_t newMinutes = getOfflineTrainingTime() / 60 / 1000; if(oldMinutes != newMinutes) sendStats(); } g_game.checkPlayersRecord(this); if(!isGhost()) { IOLoginData::getInstance()->updateOnlineStatus(guid, true); for(AutoList<Player>::iterator it = autoList.begin(); it != autoList.end(); ++it) it->second->notifyStatusChange(this, VIPSTATUS_ONLINE); } else { for(AutoList<Player>::iterator it = autoList.begin(); it != autoList.end(); ++it) { if(it->second->canSeeCreature(this)) it->second->notifyStatusChange(this, VIPSTATUS_ONLINE); } } if(g_config.getBool(ConfigManager::DISPLAY_LOGGING)) std::clog << name << " has logged in." << std::endl; } void Player::onTargetDisappear(bool isLogout) { sendCancelTarget(); if(!isLogout) sendTextMessage(MSG_STATUS_SMALL, "Target lost."); } void Player::onFollowCreatureDisappear(bool isLogout) { sendCancelTarget(); if(!isLogout) sendTextMessage(MSG_STATUS_SMALL, "Target lost."); } void Player::onChangeZone(ZoneType_t zone) { if(zone == ZONE_PROTECTION && !hasFlag(PlayerFlag_IgnoreProtectionZone)) { if(attackedCreature) { setAttackedCreature(NULL); onTargetDisappear(false); } if(g_config.getBool(ConfigManager::UNMOUNT_PLAYER_IN_PZ)) dismount(true); } g_game.updateCreatureWalkthrough(this); sendIcons(); } void Player::onTargetChangeZone(ZoneType_t zone) { if(zone == ZONE_PROTECTION && !hasFlag(PlayerFlag_IgnoreProtectionZone)) { setAttackedCreature(NULL); onTargetDisappear(false); } else if(zone == ZONE_OPTIONAL && attackedCreature->getPlayer() && !hasFlag(PlayerFlag_IgnoreProtectionZone)) { setAttackedCreature(NULL); onTargetDisappear(false); } else if(zone == ZONE_OPEN && g_game.getWorldType() == WORLDTYPE_OPTIONAL && attackedCreature->getPlayer() && !attackedCreature->getPlayer()->isEnemy(this, true)) { //attackedCreature can leave a pvp zone if not pzlocked setAttackedCreature(NULL); onTargetDisappear(false); } } void Player::onCreatureDisappear(const Creature* creature, bool isLogout) { Creature::onCreatureDisappear(creature, isLogout); if(creature != this) return; if(isLogout) loginPosition = getPosition(); lastLogout = time(NULL); Item* item = NULL; for(int32_t slot = SLOT_FIRST; slot < SLOT_LAST; ++slot) { if(!(item = getInventoryItem((slots_t)slot))) continue; g_moveEvents->onPlayerDeEquip(this, item, (slots_t)slot, false); } if(eventWalk) setFollowCreature(NULL); closeShopWindow(); if(tradePartner) g_game.internalCloseTrade(this); clearPartyInvitations(); if(party) party->leave(this); g_chat.removeUserFromChannels(this); if(!isGhost()) IOLoginData::getInstance()->updateOnlineStatus(guid, false); if(g_config.getBool(ConfigManager::DISPLAY_LOGGING)) std::clog << getName() << " has logged out." << std::endl; bool saved = false; for(uint32_t tries = 0; !saved && tries < 3; ++tries) { if(IOLoginData::getInstance()->savePlayer(this)) saved = true; #ifdef __DEBUG__ else std::clog << "Error while saving player: " << getName() << ", strike " << tries << "." << std::endl; #endif } if(!saved) #ifndef __DEBUG__ std::clog << "Error while saving player: " << getName() << "." << std::endl; #else std::clog << "Player " << getName() << " couldn't be saved." << std::endl; #endif } void Player::openShopWindow(Npc* npc) { sendShop(npc); sendGoods(); } void Player::closeShopWindow(bool send/* = true*/) { int32_t onBuy = -1, onSell = -1; if(Npc* npc = getShopOwner(onBuy, onSell)) npc->onPlayerEndTrade(this, onBuy, onSell); if(shopOwner) { shopOwner = NULL; if(send) sendCloseShop(); } purchaseCallback = saleCallback = -1; shopOffer.clear(); } bool Player::canShopItem(uint16_t itemId, uint8_t subType, ShopEvent_t event) { for(ShopInfoList::iterator sit = shopOffer.begin(); sit != shopOffer.end(); ++sit) { if(sit->itemId != itemId || ((event != SHOPEVENT_BUY || sit->buyPrice < 0) && (event != SHOPEVENT_SELL || sit->sellPrice < 0))) continue; if(event == SHOPEVENT_SELL) return true; const ItemType& it = Item::items[id]; if(it.isFluidContainer() || it.isSplash()) { if(sit->subType == subType) return true; } else return true; } return false; } void Player::onWalk(Direction& dir) { Creature::onWalk(dir); setNextActionTask(NULL); } void Player::onCreatureMove(const Creature* creature, const Tile* newTile, const Position& newPos, const Tile* oldTile, const Position& oldPos, bool teleport) { Creature::onCreatureMove(creature, newTile, newPos, oldTile, oldPos, teleport); if(creature != this) return; if(getParty()) getParty()->updateSharedExperience(); //check if we should close trade if(tradeState != TRADE_TRANSFER && ((tradeItem && !Position::areInRange<1,1,0>(tradeItem->getPosition(), getPosition())) || (tradePartner && !Position::areInRange<2,2,0>(tradePartner->getPosition(), getPosition())))) g_game.internalCloseTrade(this); if((teleport || oldPos.z != newPos.z) && !hasCustomFlag(PlayerCustomFlag_CanStairhop)) { int32_t ticks = g_config.getNumber(ConfigManager::STAIRHOP_DELAY); if(ticks > 0) { if(Condition* condition = Condition::createCondition(CONDITIONID_DEFAULT, CONDITION_PACIFIED, ticks)) addCondition(condition); } } // unset editing house if (editHouse && !newTile->hasFlag(TILESTATE_HOUSE)) editHouse = NULL; } void Player::onAddContainerItem(const Container* container, const Item* item) { checkTradeState(item); if(backpack.first && (const_cast<Container*>(container) != backpack.first || backpack.first->full())) backpack.first = NULL; } void Player::onUpdateContainerItem(const Container* container, uint8_t, const Item* oldItem, const ItemType&, const Item* newItem, const ItemType&) { if(tradeState == TRADE_TRANSFER) return; checkTradeState(oldItem); if(oldItem != newItem && tradeItem) { if(tradeItem->getParent() != container && container->isHoldingItem(tradeItem)) g_game.internalCloseTrade(this); } if(tradeState != TRADE_TRANSFER) checkTradeState(oldItem); } void Player::onRemoveContainerItem(const Container* container, uint8_t, const Item* item) { backpack.first = NULL; if(tradeState == TRADE_TRANSFER) return; checkTradeState(item); if(tradeItem) { if(tradeItem->getParent() != container && container->isHoldingItem(tradeItem)) g_game.internalCloseTrade(this); } } void Player::onCloseContainer(const Container* container) { if(!client) return; for(ContainerVector::const_iterator cl = containerVec.begin(); cl != containerVec.end(); ++cl) { if(cl->second == container) client->sendCloseContainer(cl->first); } } void Player::onSendContainer(const Container* container) { if(!client) return; bool hasParent = dynamic_cast<const Container*>(container->getParent()) != NULL; for(ContainerVector::const_iterator cl = containerVec.begin(); cl != containerVec.end(); ++cl) { if(cl->second == container) client->sendContainer(cl->first, container, hasParent); } } void Player::onUpdateInventoryItem(slots_t, Item* oldItem, const ItemType&, Item* newItem, const ItemType&) { if(tradeState == TRADE_TRANSFER) return; checkTradeState(oldItem); if(oldItem != newItem && tradeItem) { const Container* container = oldItem->getContainer(); if(container && container->isHoldingItem(tradeItem)) g_game.internalCloseTrade(this); } if(tradeState != TRADE_TRANSFER) checkTradeState(oldItem); } void Player::onRemoveInventoryItem(slots_t, Item* item) { backpack.first = NULL; if(tradeState == TRADE_TRANSFER) return; checkTradeState(item); if(tradeItem) { const Container* container = item->getContainer(); if(container && container->isHoldingItem(tradeItem)) g_game.internalCloseTrade(this); } } void Player::checkTradeState(const Item* item) { if(!tradeItem || tradeState == TRADE_TRANSFER) return; if(tradeItem != item) { const Container* container = dynamic_cast<const Container*>(item->getParent()); while(container != NULL) { if(container == tradeItem) { g_game.internalCloseTrade(this); break; } container = dynamic_cast<const Container*>(container->getParent()); } } else g_game.internalCloseTrade(this); } void Player::setNextWalkActionTask(SchedulerTask* task) { if(walkTaskEvent) { Scheduler::getInstance().stopEvent(walkTaskEvent); walkTaskEvent = 0; } delete walkTask; walkTask = task; setIdleTime(0); } void Player::setNextWalkTask(SchedulerTask* task) { if(nextStepEvent) { Scheduler::getInstance().stopEvent(nextStepEvent); nextStepEvent = 0; } if(task) { nextStepEvent = Scheduler::getInstance().addEvent(task); setIdleTime(0); } } void Player::setNextActionTask(SchedulerTask* task) { if(actionTaskEvent) { Scheduler::getInstance().stopEvent(actionTaskEvent); actionTaskEvent = 0; } if(task) { actionTaskEvent = Scheduler::getInstance().addEvent(task); setIdleTime(0); } } uint32_t Player::getNextActionTime(bool scheduler/* = true*/) const { if(!scheduler) return (uint32_t)std::max((int64_t)0, ((int64_t)nextAction - OTSYS_TIME())); return (uint32_t)std::max((int64_t)SCHEDULER_MINTICKS, ((int64_t)nextAction - OTSYS_TIME())); } void Player::onThink(uint32_t interval) { Creature::onThink(interval); int64_t timeNow = OTSYS_TIME(); if(timeNow - lastPing >= 5000) { lastPing = timeNow; if(hasClient()) client->sendPing(); else if(g_config.getBool(ConfigManager::STOP_ATTACK_AT_EXIT)) setAttackedCreature(NULL); } if((timeNow - lastPong) >= 60000 && !getTile()->hasFlag(TILESTATE_NOLOGOUT) && !isConnecting && !pzLocked && !hasCondition(CONDITION_INFIGHT)) { if(hasClient()) client->logout(true, true); else if(g_creatureEvents->playerLogout(this, false)) g_game.removeCreature(this, true); } messageTicks += interval; if(messageTicks >= 1500) { messageTicks = 0; addMessageBuffer(); } if(lastMail && lastMail < (uint64_t)(OTSYS_TIME() + g_config.getNumber(ConfigManager::MAIL_ATTEMPTS_FADE))) mailAttempts = lastMail = 0; addOfflineTrainingTime(interval); if(lastStatsTrainingTime != getOfflineTrainingTime() / 60 / 1000) sendStats(); } bool Player::isMuted(uint16_t channelId, MessageClasses type, int32_t& time) { time = 0; if(hasFlag(PlayerFlag_CannotBeMuted)) return false; int32_t muteTicks = 0; for(ConditionList::iterator it = conditions.begin(); it != conditions.end(); ++it) { if((*it)->getType() == CONDITION_MUTED && (*it)->getSubId() == 0) { if((*it)->getTicks() == -1) { time = -1; break; } if((*it)->getTicks() > muteTicks) muteTicks = (*it)->getTicks(); } } if(muteTicks) time = (uint32_t)muteTicks / 1000; return type != MSG_NPC_TO && (type != MSG_CHANNEL || (channelId != CHANNEL_GUILD && !g_chat.isPrivateChannel(channelId))); } void Player::addMessageBuffer() { if(!hasFlag(PlayerFlag_CannotBeMuted) && g_config.getNumber(ConfigManager::MAX_MESSAGEBUFFER) && messageBuffer) messageBuffer--; } void Player::removeMessageBuffer() { if(hasFlag(PlayerFlag_CannotBeMuted)) return; int32_t maxBuffer = g_config.getNumber(ConfigManager::MAX_MESSAGEBUFFER); if(!maxBuffer || messageBuffer > maxBuffer + 1 || ++messageBuffer <= maxBuffer) return; uint32_t muteCount = 1; MuteCountMap::iterator it = muteCountMap.find(guid); if(it != muteCountMap.end()) muteCount = it->second; uint32_t muteTime = 5 * muteCount * muteCount; muteCountMap[guid] = muteCount + 1; if(Condition* condition = Condition::createCondition(CONDITIONID_DEFAULT, CONDITION_MUTED, muteTime * 1000)) addCondition(condition); char buffer[50]; sprintf(buffer, "You are muted for %d seconds.", muteTime); sendTextMessage(MSG_STATUS_SMALL, buffer); } double Player::getFreeCapacity() const { if(hasFlag(PlayerFlag_HasInfiniteCapacity) || !g_config.getBool(ConfigManager::USE_CAPACITY)) return 10000.00; return std::max(0.00, capacity - inventoryWeight); } void Player::drainHealth(Creature* attacker, CombatType_t combatType, int32_t damage) { Creature::drainHealth(attacker, combatType, damage); sendStats(); } void Player::drainMana(Creature* attacker, CombatType_t combatType, int32_t damage) { Creature::drainMana(attacker, combatType, damage); sendStats(); } void Player::addManaSpent(uint64_t amount, bool useMultiplier/* = true*/) { if(!amount) return; uint64_t currReqMana = vocation->getReqMana(magLevel), nextReqMana = vocation->getReqMana(magLevel + 1); if(magLevel > 0 && currReqMana > nextReqMana) //player has reached max magic level return; if(useMultiplier) amount = uint64_t((double)amount * rates[SKILL__MAGLEVEL] * g_config.getDouble(ConfigManager::RATE_MAGIC)); std::stringstream s; while(manaSpent + amount >= nextReqMana) { amount -= nextReqMana - manaSpent; manaSpent = 0; s.str(""); s << "You advanced to magic level " << ++magLevel << "."; sendTextMessage(MSG_EVENT_ADVANCE, s.str()); CreatureEventList advanceEvents = getCreatureEvents(CREATURE_EVENT_ADVANCE); for(CreatureEventList::iterator it = advanceEvents.begin(); it != advanceEvents.end(); ++it) (*it)->executeAdvance(this, SKILL__MAGLEVEL, (magLevel - 1), magLevel); currReqMana = nextReqMana; nextReqMana = vocation->getReqMana(magLevel + 1); if(currReqMana > nextReqMana) { amount = 0; break; } } if(amount) manaSpent += amount; uint16_t newPercent = Player::getPercentLevel(manaSpent, nextReqMana); if(magLevelPercent != newPercent) { magLevelPercent = newPercent; sendStats(); } else if(!s.str().empty()) sendStats(); } void Player::addExperience(uint64_t exp) { bool attackable = isProtected(); uint32_t prevLevel = level; uint64_t nextLevelExp = Player::getExpForLevel(level + 1); if(Player::getExpForLevel(level) > nextLevelExp) { //player has reached max level levelPercent = 0; sendStats(); return; } experience += exp; while(experience >= nextLevelExp) { ++level; Vocation* voc = vocation; if(voc->getId() > 0 && g_config.getBool(ConfigManager::ROOK_SYSTEM) && level <= (uint32_t)g_config.getNumber(ConfigManager::ROOK_TOLEVEL)) { if(Vocation* tmp = Vocations::getInstance()->getVocation(0)) voc = tmp; } healthMax += voc->getGain(GAIN_HEALTH); health += voc->getGain(GAIN_HEALTH); manaMax += voc->getGain(GAIN_MANA); mana += voc->getGain(GAIN_MANA); capacity += voc->getGainCap(); nextLevelExp = Player::getExpForLevel(level + 1); if(Player::getExpForLevel(level) > nextLevelExp) //player has reached max level break; } if(prevLevel != level) { updateBaseSpeed(); g_game.changeSpeed(this, 0); if(party) party->updateSharedExperience(); CreatureEventList advanceEvents = getCreatureEvents(CREATURE_EVENT_ADVANCE); for(CreatureEventList::iterator it = advanceEvents.begin(); it != advanceEvents.end(); ++it) (*it)->executeAdvance(this, SKILL__LEVEL, prevLevel, level); std::stringstream s; s << "You advanced from Level " << prevLevel << " to Level " << level << "."; sendTextMessage(MSG_EVENT_ADVANCE, s.str()); if(isProtected() != attackable) g_game.updateCreatureWalkthrough(this); } uint64_t currLevelExp = Player::getExpForLevel(level); nextLevelExp = Player::getExpForLevel(level + 1); levelPercent = 0; if(nextLevelExp > currLevelExp) levelPercent = Player::getPercentLevel(experience - currLevelExp, nextLevelExp - currLevelExp); sendStats(); } void Player::removeExperience(uint64_t exp, bool updateStats/* = true*/) { uint32_t prevLevel = level; bool attackable = isProtected(); experience -= std::min(exp, experience); while(level > 1 && experience < Player::getExpForLevel(level)) { --level; Vocation* voc = vocation; if(voc->getId() > 0 && g_config.getBool(ConfigManager::ROOK_SYSTEM) && level < (uint32_t)g_config.getNumber(ConfigManager::ROOK_TOLEVEL)) { if(Vocation* tmp = Vocations::getInstance()->getVocation(0)) voc = tmp; } healthMax = std::max((int32_t)0, (healthMax - (int32_t)voc->getGain(GAIN_HEALTH))); manaMax = std::max((int32_t)0, (manaMax - (int32_t)voc->getGain(GAIN_MANA))); capacity = std::max((double)0, (capacity - (double)voc->getGainCap())); } if(prevLevel != level) { if(updateStats) { updateBaseSpeed(); g_game.changeSpeed(this, 0); g_game.addCreatureHealth(this); } CreatureEventList advanceEvents = getCreatureEvents(CREATURE_EVENT_ADVANCE); for(CreatureEventList::iterator it = advanceEvents.begin(); it != advanceEvents.end(); ++it) (*it)->executeAdvance(this, SKILL__LEVEL, prevLevel, level); std::stringstream s; s << "You were downgraded from Level " << prevLevel << " to Level " << level << "."; sendTextMessage(MSG_EVENT_ADVANCE, s.str()); if(!isProtected() != attackable) g_game.updateCreatureWalkthrough(this); } uint64_t currLevelExp = Player::getExpForLevel(level), nextLevelExp = Player::getExpForLevel(level + 1); if(nextLevelExp > currLevelExp) levelPercent = Player::getPercentLevel(experience - currLevelExp, nextLevelExp - currLevelExp); else levelPercent = 0; if(updateStats) sendStats(); } uint16_t Player::getPercentLevel(uint64_t count, uint64_t nextLevelCount) { if(nextLevelCount > 0) return std::min((uint32_t)100, std::max((uint32_t)0, uint32_t(count * 100 / nextLevelCount))); return 0; } void Player::onBlockHit(BlockType_t) { if(shieldBlockCount > 0) { --shieldBlockCount; if(hasShield()) addSkillAdvance(SKILL_SHIELD, 1); } } void Player::onTargetBlockHit(Creature* target, BlockType_t blockType) { Creature::onTargetBlockHit(target, blockType); lastAttackBlockType = blockType; switch(blockType) { case BLOCK_NONE: { bloodHitCount = shieldBlockCount = 30; addAttackSkillPoint = true; break; } case BLOCK_DEFENSE: case BLOCK_ARMOR: { //need to draw blood every 30 hits if(bloodHitCount > 0) { addAttackSkillPoint = true; --bloodHitCount; } else addAttackSkillPoint = false; break; } default: { addAttackSkillPoint = false; break; } } } bool Player::hasShield() const { Item* item = getInventoryItem(SLOT_LEFT); return (item && item->getWeaponType() == WEAPON_SHIELD) || ((item = getInventoryItem(SLOT_RIGHT)) && item->getWeaponType() == WEAPON_SHIELD); } BlockType_t Player::blockHit(Creature* attacker, CombatType_t combatType, int32_t& damage, bool checkDefense/* = false*/, bool checkArmor/* = false*/, bool reflect/* = true*/, bool field/* = false*/, bool element/* = false*/) { BlockType_t blockType = Creature::blockHit(attacker, combatType, damage, checkDefense, checkArmor, reflect, field); if(attacker && !element) { int16_t color = g_config.getNumber(ConfigManager::SQUARE_COLOR); if(color < 0) color = random_range(0, 254); sendCreatureSquare(attacker, color); } if(blockType != BLOCK_NONE) return blockType; if(vocation->getMultiplier(MULTIPLIER_MAGICDEFENSE) != 1.0 && combatType != COMBAT_PHYSICALDAMAGE && combatType != COMBAT_NONE && combatType != COMBAT_UNDEFINEDDAMAGE && combatType != COMBAT_DROWNDAMAGE) damage -= (int32_t)std::ceil((double)(damage * vocation->getMultiplier(MULTIPLIER_MAGICDEFENSE)) / 100.); if(damage <= 0) return blockType; int32_t blocked = 0, reflected = 0; if(reflect) reflect = attacker && !attacker->isRemoved() && attacker->getHealth() > 0; Item* item = NULL; for(int32_t slot = SLOT_FIRST; slot < SLOT_LAST; ++slot) { if(!(item = getInventoryItem((slots_t)slot)) || item->isRemoved() || (g_moveEvents->hasEquipEvent(item) && !isItemAbilityEnabled((slots_t)slot))) continue; const ItemType& it = Item::items[item->getID()]; if(!it.hasAbilities()) continue; bool transform = false; if(it.abilities->absorb[combatType]) { blocked += (int32_t)std::ceil((double)(damage * it.abilities->absorb[combatType]) / 100.); if(item->hasCharges()) transform = true; } if(field && it.abilities->fieldAbsorb[combatType]) { blocked += (int32_t)std::ceil((double)(damage * it.abilities->fieldAbsorb[combatType]) / 100.); if(item->hasCharges()) transform = true; } if(reflect && it.abilities->reflect[REFLECT_PERCENT][combatType] && it.abilities->reflect[REFLECT_CHANCE][combatType] >= random_range(1, 100)) { reflected += (int32_t)std::ceil((double)(damage * it.abilities->reflect[REFLECT_PERCENT][combatType]) / 100.); if(item->hasCharges()) transform = true; } if(!element && transform) g_game.transformItem(item, item->getID(), std::max((int32_t)0, (int32_t)item->getCharges() - 1)); } if(outfitAttributes) { uint32_t tmp = Outfits::getInstance()->getOutfitAbsorb(defaultOutfit.lookType, sex, combatType); if(tmp) blocked += (int32_t)std::ceil((double)(damage * tmp) / 100.); if(reflect) { tmp = Outfits::getInstance()->getOutfitReflect(defaultOutfit.lookType, sex, combatType); if(tmp) reflected += (int32_t)std::ceil((double)(damage * tmp) / 100.); } } if(mounted) { Mount* mount = Mounts::getInstance()->getMountByCid(defaultOutfit.lookMount); if(mount) { if(mount->absorb[combatType]) blocked += (int32_t)std::ceil((double)(damage * mount->absorb[combatType]) / 100.); if(reflect && mount->reflect[REFLECT_PERCENT][combatType] && mount->reflect[REFLECT_CHANCE][combatType] >= random_range(1, 100)) reflected += (int32_t)std::ceil((double)(damage * mount->reflect[REFLECT_PERCENT][combatType]) / 100.); } } if(vocation->getAbsorb(combatType)) blocked += (int32_t)std::ceil((double)(damage * vocation->getAbsorb(combatType)) / 100.); if(reflect && vocation->getReflect(combatType)) reflected += (int32_t)std::ceil((double)(damage * vocation->getReflect(combatType)) / 100.); damage -= blocked; if(damage <= 0) { damage = 0; blockType = BLOCK_DEFENSE; } if(reflected && !element) { if(combatType != COMBAT_HEALING) reflected = -reflected; if(!g_game.combatBlockHit(combatType, this, attacker, reflected, false, false, true, false)) g_game.combatChangeHealth(combatType, NULL, attacker, reflected); } return blockType; } uint32_t Player::getIP() const { if(client) return client->getIP(); return lastIP; } bool Player::onDeath() { Item *preventLoss = NULL, *preventDrop = NULL; if(getZone() == ZONE_HARDCORE) { setDropLoot(LOOT_DROP_NONE); setLossSkill(false); } else if(skull < SKULL_RED) { Item* item = NULL; for(int32_t i = SLOT_FIRST; ((!preventDrop || !preventLoss) && i < SLOT_LAST); ++i) { if(!(item = getInventoryItem((slots_t)i)) || item->isRemoved() || (g_moveEvents->hasEquipEvent(item) && !isItemAbilityEnabled((slots_t)i))) continue; const ItemType& it = Item::items[item->getID()]; if(!it.hasAbilities()) continue; if(lootDrop == LOOT_DROP_FULL && it.abilities->preventDrop) { setDropLoot(LOOT_DROP_PREVENT); preventDrop = item; } if(skillLoss && !preventLoss && it.abilities->preventLoss) preventLoss = item; } } if(!Creature::onDeath()) { if(preventDrop) setDropLoot(LOOT_DROP_FULL); return false; } uint32_t totalDamage = 0, pvpDamage = 0, opponents = 0; for(CountMap::iterator it = damageMap.begin(); it != damageMap.end(); ++it) { if(((OTSYS_TIME() - it->second.ticks) / 1000) > g_config.getNumber( ConfigManager::FAIRFIGHT_TIMERANGE)) continue; totalDamage += it->second.total; if(Creature* creature = g_game.getCreatureByID(it->first)) { Player* player = creature->getPlayer(); if(!player) player = creature->getPlayerMaster(); if(!player) continue; opponents += player->getLevel(); pvpDamage += it->second.total; } } bool usePVPBlessing = false; if(preventLoss) { setLossSkill(false); g_game.transformItem(preventLoss, preventLoss->getID(), std::max(0, (int32_t)preventLoss->getCharges() - 1)); } else if(pvpBlessing && (int32_t)std::floor((100. * pvpDamage) / std::max( 1U, totalDamage)) >= g_config.getNumber(ConfigManager::PVP_BLESSING_THRESHOLD)) usePVPBlessing = true; if(preventDrop && preventDrop != preventLoss && !usePVPBlessing) g_game.transformItem(preventDrop, preventDrop->getID(), std::max(0, (int32_t)preventDrop->getCharges() - 1)); removeConditions(CONDITIONEND_DEATH); if(skillLoss) { double reduction = 1.; if(g_config.getBool(ConfigManager::FAIRFIGHT_REDUCTION) && opponents > level) reduction -= (double)level / opponents; uint64_t lossExperience = (uint64_t)std::floor(reduction * getLostExperience()), currExperience = experience; removeExperience(lossExperience, false); double percent = 1. - ((double)(currExperience - lossExperience) / std::max((uint64_t)1, currExperience)); // magic level loss uint64_t sumMana = 0, lostMana = 0; for(uint32_t i = 1; i <= magLevel; ++i) sumMana += vocation->getReqMana(i); sumMana += manaSpent; lostMana = (uint64_t)std::ceil((percent * lossPercent[LOSS_MANA] / 100.) * sumMana); while(lostMana > manaSpent && magLevel > 0) { lostMana -= manaSpent; manaSpent = vocation->getReqMana(magLevel); magLevel--; } manaSpent -= lostMana; uint64_t nextReqMana = vocation->getReqMana(magLevel + 1); if(nextReqMana > vocation->getReqMana(magLevel)) magLevelPercent = Player::getPercentLevel(manaSpent, nextReqMana); else magLevelPercent = 0; // skill loss uint64_t lostSkillTries, sumSkillTries; for(int16_t i = 0; i < 7; ++i) // for each skill { lostSkillTries = sumSkillTries = 0; for(uint32_t c = 11; c <= skills[i][SKILL_LEVEL]; ++c) // sum up all required tries for all skill levels sumSkillTries += vocation->getReqSkillTries(i, c); sumSkillTries += skills[i][SKILL_TRIES]; lostSkillTries = (uint64_t)std::ceil((percent * lossPercent[LOSS_SKILLS] / 100.) * sumSkillTries); while(lostSkillTries > skills[i][SKILL_TRIES] && skills[i][SKILL_LEVEL] > 10) { lostSkillTries -= skills[i][SKILL_TRIES]; skills[i][SKILL_TRIES] = vocation->getReqSkillTries(i, skills[i][SKILL_LEVEL]); skills[i][SKILL_LEVEL]--; } skills[i][SKILL_TRIES] -= lostSkillTries; } if(usePVPBlessing) pvpBlessing = false; else blessings = 0; loginPosition = masterPosition; if(vocationId > VOCATION_NONE && g_config.getBool(ConfigManager::ROOK_SYSTEM) && level <= (uint32_t)g_config.getNumber(ConfigManager::ROOK_LEVELTO)) { if(Town* rook = Towns::getInstance()->getTown(g_config.getNumber(ConfigManager::ROOK_TOWN))) { level = 1; soulMax = soul = 100; capacity = 400; stamina = STAMINA_MAX; health = healthMax = 150; loginPosition = masterPosition = rook->getPosition(); experience = magLevel = manaSpent = mana = manaMax = balance = marriage = 0; promotionLevel = defaultOutfit.lookAddons = defaultOutfit.lookMount = 0; setTown(rook->getID()); setVocation(0); leaveGuild(); storageMap.clear(); for(uint32_t i = SKILL_FIRST; i <= SKILL_LAST; ++i) { skills[i][SKILL_LEVEL] = 10; skills[i][SKILL_TRIES] = 0; } for(uint32_t i = SLOT_FIRST; i < SLOT_LAST; ++i) { if(inventory[i]) g_game.internalRemoveItem(NULL, inventory[i]); } } } else if(!inventory[SLOT_BACKPACK]) // FIXME: you should receive the bag after you login back... __internalAddThing(SLOT_BACKPACK, Item::CreateItem(g_config.getNumber(ConfigManager::DEATH_CONTAINER))); sendIcons(); sendStats(); sendSkills(); g_creatureEvents->playerLogout(this, true); g_game.removeCreature(this, false); sendReLoginWindow((uint8_t)std::floor((1. - reduction) * 100.)); } else { setLossSkill(true); if(preventLoss) { loginPosition = masterPosition; g_creatureEvents->playerLogout(this, true); g_game.removeCreature(this, false); sendReLoginWindow(0); } } return true; } void Player::dropCorpse(DeathList deathList) { if(lootDrop == LOOT_DROP_NONE) { pzLocked = false; if(health <= 0) { health = healthMax; if(getZone() != ZONE_HARDCORE || g_config.getBool(ConfigManager::PVPZONE_RECOVERMANA)) mana = manaMax; } setDropLoot(LOOT_DROP_FULL); sendStats(); sendIcons(); onIdleStatus(); g_game.addCreatureHealth(this); g_game.internalTeleport(this, masterPosition, false); } else { Creature::dropCorpse(deathList); if(g_config.getBool(ConfigManager::DEATH_LIST)) IOLoginData::getInstance()->playerDeath(this, deathList); } } Item* Player::createCorpse(DeathList deathList) { Item* corpse = Creature::createCorpse(deathList); if(!corpse) return NULL; std::stringstream ss; ss << "You recognize " << nameDescription << ". " << (sex % 2 ? "He" : "She") << " was killed by "; if(deathList[0].isCreatureKill()) { ss << deathList[0].getKillerCreature()->getNameDescription(); if(deathList[0].getKillerCreature()->getMaster()) ss << " summoned by " << deathList[0].getKillerCreature()->getMaster()->getNameDescription(); } else ss << deathList[0].getKillerName(); if(deathList.size() > 1 && g_config.getBool(ConfigManager::MULTIPLE_NAME)) { if(deathList[0].getKillerType() != deathList[1].getKillerType()) { if(deathList[1].isCreatureKill()) { ss << " and by " << deathList[1].getKillerCreature()->getNameDescription(); if(deathList[1].getKillerCreature()->getMaster()) ss << " summoned by " << deathList[1].getKillerCreature()->getMaster()->getNameDescription(); } else ss << " and by " << deathList[1].getKillerName(); } else if(deathList[1].isCreatureKill()) { if(deathList[0].getKillerCreature()->getName() != deathList[1].getKillerCreature()->getName()) { ss << " and by " << deathList[1].getKillerCreature()->getNameDescription(); if(deathList[1].getKillerCreature()->getMaster()) ss << " summoned by " << deathList[1].getKillerCreature()->getMaster()->getNameDescription(); } } else if(asLowerCaseString(deathList[0].getKillerName()) != asLowerCaseString(deathList[1].getKillerName())) ss << " and by " << deathList[1].getKillerName(); } ss << "."; corpse->setSpecialDescription(ss.str().c_str()); return corpse; } void Player::addCooldown(uint32_t ticks, uint16_t spellId) { if(Condition* condition = Condition::createCondition(CONDITIONID_DEFAULT, CONDITION_SPELLCOOLDOWN, ticks, 0, false, spellId)) addCondition(condition); } void Player::addExhaust(uint32_t ticks, Exhaust_t exhaust) { if(Condition* condition = Condition::createCondition(CONDITIONID_DEFAULT, CONDITION_EXHAUST, ticks, 0, false, (int32_t)exhaust)) addCondition(condition); } void Player::addInFightTicks(bool pzLock, int32_t ticks/* = 0*/) { if(hasFlag(PlayerFlag_NotGainInFight)) return; if(!ticks) ticks = g_config.getNumber(ConfigManager::PZ_LOCKED); else ticks = std::max(-1, ticks); if(pzLock) pzLocked = true; if(Condition* condition = Condition::createCondition(CONDITIONID_DEFAULT, CONDITION_INFIGHT, ticks)) addCondition(condition); } void Player::addDefaultRegeneration(uint32_t addTicks) { Condition* condition = getCondition(CONDITION_REGENERATION, CONDITIONID_DEFAULT); if(condition) condition->setTicks(condition->getTicks() + addTicks); else if((condition = Condition::createCondition(CONDITIONID_DEFAULT, CONDITION_REGENERATION, addTicks))) { condition->setParam(CONDITIONPARAM_HEALTHGAIN, vocation->getGainAmount(GAIN_HEALTH)); condition->setParam(CONDITIONPARAM_HEALTHTICKS, vocation->getGainTicks(GAIN_HEALTH) * 1000); condition->setParam(CONDITIONPARAM_MANAGAIN, vocation->getGainAmount(GAIN_MANA)); condition->setParam(CONDITIONPARAM_MANATICKS, vocation->getGainTicks(GAIN_MANA) * 1000); addCondition(condition); } } void Player::removeList() { Manager::getInstance()->removeUser(id); autoList.erase(id); if(!isGhost()) { for(AutoList<Player>::iterator it = autoList.begin(); it != autoList.end(); ++it) it->second->notifyStatusChange(this, VIPSTATUS_OFFLINE); } else { for(AutoList<Player>::iterator it = autoList.begin(); it != autoList.end(); ++it) { if(it->second->canSeeCreature(this)) it->second->notifyStatusChange(this, VIPSTATUS_OFFLINE); } } } void Player::addList() { autoList[id] = this; Manager::getInstance()->addUser(this); } void Player::kick(bool displayEffect, bool forceLogout) { if(!hasClient()) { if(g_creatureEvents->playerLogout(this, forceLogout)) g_game.removeCreature(this); } else client->logout(displayEffect, forceLogout); } void Player::notifyStatusChange(Player* loginPlayer, VipStatus_t status) { if(!client) return; VIPMap::iterator it = VIPList.find(loginPlayer->getGUID()); if(it != VIPList.end()) client->sendUpdatedVIPStatus(loginPlayer->getGUID(), status); } bool Player::removeVIP(uint32_t _guid) { VIPMap::iterator it = VIPList.find(_guid); if(it == VIPList.end()) return false; VIPList.erase(it); return true; } bool Player::addVIP(uint32_t _guid, const std::string& name, const std::string& description, const uint32_t& icon, bool notify, VipStatus_t status, bool loading/* = false*/) { if(guid == _guid) { if(!loading) sendTextMessage(MSG_STATUS_SMALL, "You cannot add yourself."); return false; } if(!loading && VIPList.size() > (size_t)(group ? group->getMaxVips(isPremium()) : g_config.getNumber(ConfigManager::VIPLIST_DEFAULT_LIMIT))) { sendTextMessage(MSG_STATUS_SMALL, "You cannot add more buddies."); return false; } VIPMap::iterator it = VIPList.find(_guid); if(it != VIPList.end()) { if(!loading) sendTextMessage(MSG_STATUS_SMALL, "This player is already in your list."); return false; } VIP_t tmp; tmp.description = description; tmp.icon = icon; tmp.notify = notify; VIPList.insert(VIPPair(_guid, tmp)); if(!loading && client) client->sendVIP(_guid, name, tmp.description, tmp.icon, tmp.notify, status); return true; } bool Player::editVIP(uint32_t _guid, const std::string& description, const uint32_t& icon, bool notify) { VIPMap::iterator it = VIPList.find(_guid); if(it == VIPList.end()) return false; (*it).second.description = description; (*it).second.icon = icon; (*it).second.notify = notify; return true; } //close container and its child containers void Player::autoCloseContainers(const Container* container) { typedef std::vector<uint32_t> CloseList; CloseList closeList; for(ContainerVector::iterator it = containerVec.begin(); it != containerVec.end(); ++it) { Container* tmp = it->second; while(tmp != NULL) { if(tmp->isRemoved() || tmp == container) { closeList.push_back(it->first); break; } tmp = dynamic_cast<Container*>(tmp->getParent()); } } for(CloseList::iterator it = closeList.begin(); it != closeList.end(); ++it) { closeContainer(*it); if(client) client->sendCloseContainer(*it); } } bool Player::hasCapacity(const Item* item, uint32_t count) const { if(hasFlag(PlayerFlag_HasInfiniteCapacity) || item->getTopParent() == this) return true; double itemWeight = 0; if(item->isStackable()) itemWeight = Item::items[item->getID()].weight * count; else itemWeight = item->getWeight(); return (itemWeight < getFreeCapacity()); } ReturnValue Player::__queryAdd(int32_t index, const Thing* thing, uint32_t count, uint32_t flags, Creature*) const { const Item* item = thing->getItem(); if(!item) return RET_NOTPOSSIBLE; if(!item->isPickupable() || (hasFlag(PlayerFlag_CannotPickupItem) && item->getParent() && item->getParent() != VirtualCylinder::virtualCylinder)) return RET_CANNOTPICKUP; bool childOwner = ((flags & FLAG_CHILDISOWNER) == FLAG_CHILDISOWNER), skipLimit = ((flags & FLAG_NOLIMIT) == FLAG_NOLIMIT); if(childOwner) { //a child container is querying the player, just check if enough capacity if(skipLimit || hasCapacity(item, count)) return RET_NOERROR; return RET_NOTENOUGHCAPACITY; } ReturnValue ret = RET_NOERROR; if((item->getSlotPosition() & SLOTP_HEAD) || (item->getSlotPosition() & SLOTP_NECKLACE) || (item->getSlotPosition() & SLOTP_BACKPACK) || (item->getSlotPosition() & SLOTP_ARMOR) || (item->getSlotPosition() & SLOTP_LEGS) || (item->getSlotPosition() & SLOTP_FEET) || (item->getSlotPosition() & SLOTP_RING) || (item->getSlotPosition() & SLOTP_AMMO)) ret = RET_CANNOTBEDRESSED; else if(item->getSlotPosition() & SLOTP_TWO_HAND) ret = RET_PUTTHISOBJECTINBOTHHANDS; else if((item->getSlotPosition() & SLOTP_RIGHT) || (item->getSlotPosition() & SLOTP_LEFT)) ret = RET_PUTTHISOBJECTINYOURHAND; switch(index) { case SLOT_HEAD: if(item->getSlotPosition() & SLOTP_HEAD) ret = RET_NOERROR; break; case SLOT_NECKLACE: if(item->getSlotPosition() & SLOTP_NECKLACE) ret = RET_NOERROR; break; case SLOT_BACKPACK: if(item->getSlotPosition() & SLOTP_BACKPACK) ret = RET_NOERROR; break; case SLOT_ARMOR: if(item->getSlotPosition() & SLOTP_ARMOR) ret = RET_NOERROR; break; case SLOT_RIGHT: if(item->getSlotPosition() & SLOTP_RIGHT) { if(!g_config.getBool(ConfigManager::TIBIA_SLOTS)) { if(!item->isWeapon() || (item->getWeaponType() != WEAPON_SHIELD && !item->isDualWield())) ret = RET_NOTPOSSIBLE; else if(inventory[SLOT_LEFT] && inventory[SLOT_LEFT]->getSlotPosition() & SLOTP_TWO_HAND) ret = RET_DROPTWOHANDEDITEM; else ret = RET_NOERROR; } else if(item->getSlotPosition() & SLOTP_TWO_HAND) { if(inventory[SLOT_LEFT] && inventory[SLOT_LEFT] != item) ret = RET_BOTHHANDSNEEDTOBEFREE; else ret = RET_NOERROR; } else if(inventory[SLOT_LEFT]) { const Item* leftItem = inventory[SLOT_LEFT]; WeaponType_t type = item->getWeaponType(), leftType = leftItem->getWeaponType(); if(leftItem->getSlotPosition() & SLOTP_TWO_HAND) ret = RET_DROPTWOHANDEDITEM; else if(item == leftItem && item->getItemCount() == count) ret = RET_NOERROR; else if(leftType == WEAPON_SHIELD && type == WEAPON_SHIELD) ret = RET_CANONLYUSEONESHIELD; else if(!leftItem->isWeapon() || !item->isWeapon() || leftType == WEAPON_AMMO || type == WEAPON_AMMO || leftType == WEAPON_SHIELD || type == WEAPON_SHIELD || (leftItem->isDualWield() && item->isDualWield())) ret = RET_NOERROR; else ret = RET_CANONLYUSEONEWEAPON; } else ret = RET_NOERROR; } break; case SLOT_LEFT: if(item->getSlotPosition() & SLOTP_LEFT) { if(!g_config.getBool(ConfigManager::TIBIA_SLOTS)) { if(!item->isWeapon() || item->getWeaponType() == WEAPON_SHIELD) ret = RET_NOTPOSSIBLE; else if(inventory[SLOT_RIGHT] && item->getSlotPosition() & SLOTP_TWO_HAND) ret = RET_BOTHHANDSNEEDTOBEFREE; else ret = RET_NOERROR; } else if(item->getSlotPosition() & SLOTP_TWO_HAND) { if(inventory[SLOT_RIGHT] && inventory[SLOT_RIGHT] != item) ret = RET_BOTHHANDSNEEDTOBEFREE; else ret = RET_NOERROR; } else if(inventory[SLOT_RIGHT]) { const Item* rightItem = inventory[SLOT_RIGHT]; WeaponType_t type = item->getWeaponType(), rightType = rightItem->getWeaponType(); if(rightItem->getSlotPosition() & SLOTP_TWO_HAND) ret = RET_DROPTWOHANDEDITEM; else if(item == rightItem && item->getItemCount() == count) ret = RET_NOERROR; else if(rightType == WEAPON_SHIELD && type == WEAPON_SHIELD) ret = RET_CANONLYUSEONESHIELD; else if(!rightItem->isWeapon() || !item->isWeapon() || rightType == WEAPON_AMMO || type == WEAPON_AMMO || rightType == WEAPON_SHIELD || type == WEAPON_SHIELD || (rightItem->isDualWield() && item->isDualWield())) ret = RET_NOERROR; else ret = RET_CANONLYUSEONEWEAPON; } else ret = RET_NOERROR; } break; case SLOT_LEGS: if(item->getSlotPosition() & SLOTP_LEGS) ret = RET_NOERROR; break; case SLOT_FEET: if(item->getSlotPosition() & SLOTP_FEET) ret = RET_NOERROR; break; case SLOT_RING: if(item->getSlotPosition() & SLOTP_RING) ret = RET_NOERROR; break; case SLOT_AMMO: if(item->getSlotPosition() & SLOTP_AMMO || g_config.getBool(ConfigManager::TIBIA_SLOTS)) ret = RET_NOERROR; break; case SLOT_WHEREEVER: case -1: ret = RET_NOTENOUGHROOM; break; default: ret = RET_NOTPOSSIBLE; break; } Player* self = const_cast<Player*>(this); if(ret == RET_NOERROR) { //need an exchange with source? Item* tmpItem = NULL; if((tmpItem = getInventoryItem((slots_t)index)) && (!tmpItem->isStackable() || tmpItem->getID() != item->getID())) return RET_NEEDEXCHANGE; if(!g_moveEvents->onPlayerEquip(self, const_cast<Item*>(item), (slots_t)index, true)) return RET_CANNOTBEDRESSED; } if((ret == RET_NOERROR || ret == RET_NOTENOUGHROOM) && !hasCapacity(item, count)) //check if enough capacity return RET_NOTENOUGHCAPACITY; if(index == SLOT_LEFT || index == SLOT_RIGHT) { if(ret == RET_NOERROR && item->getWeaponType() != WEAPON_NONE) self->setLastAttack(OTSYS_TIME()); Item* tmpItem = inventory[(slots_t)index]; if(ret == RET_BOTHHANDSNEEDTOBEFREE && g_game.internalAddItem( NULL, self, tmpItem, INDEX_WHEREEVER) == RET_NOERROR) { self->sendRemoveInventoryItem((slots_t)index, tmpItem); self->onRemoveInventoryItem((slots_t)index, tmpItem); self->inventory[(slots_t)index] = NULL; self->updateWeapon(); self->inventoryWeight -= tmpItem->getWeight(); self->sendStats(); } } return ret; } ReturnValue Player::__queryMaxCount(int32_t index, const Thing* thing, uint32_t count, uint32_t& maxQueryCount, uint32_t flags) const { const Item* item = thing->getItem(); if(!item) { maxQueryCount = 0; return RET_NOTPOSSIBLE; } if(index == INDEX_WHEREEVER) { uint32_t n = 0; for(int32_t i = SLOT_FIRST; i < SLOT_LAST; ++i) { if(Item* inventoryItem = inventory[i]) { if(Container* subContainer = inventoryItem->getContainer()) { uint32_t queryCount = 0; subContainer->__queryMaxCount(INDEX_WHEREEVER, item, item->getItemCount(), queryCount, flags); //iterate through all items, including sub-containers (deep search) n += queryCount; for(ContainerIterator cit = subContainer->begin(); cit != subContainer->end(); ++cit) { if(Container* tmpContainer = (*cit)->getContainer()) { queryCount = 0; tmpContainer->__queryMaxCount(INDEX_WHEREEVER, item, item->getItemCount(), queryCount, flags); n += queryCount; } } } else if(inventoryItem->isStackable() && item->getID() == inventoryItem->getID() && inventoryItem->getItemCount() < 100) { uint32_t remainder = (100 - inventoryItem->getItemCount()); if(__queryAdd(i, item, remainder, flags) == RET_NOERROR) n += remainder; } } else if(__queryAdd(i, item, item->getItemCount(), flags) == RET_NOERROR) { if(item->isStackable()) n += 100; else n += 1; } } maxQueryCount = n; } else { const Thing* destThing = __getThing(index); const Item* destItem = NULL; if(destThing) destItem = destThing->getItem(); if(destItem) { if(destItem->isStackable() && item->getID() == destItem->getID() && destItem->getItemCount() < 100) maxQueryCount = 100 - destItem->getItemCount(); else maxQueryCount = 0; } else if(__queryAdd(index, item, count, flags) == RET_NOERROR) { if(item->isStackable()) maxQueryCount = 100; else maxQueryCount = 1; return RET_NOERROR; } } if(maxQueryCount < count) return RET_NOTENOUGHROOM; return RET_NOERROR; } ReturnValue Player::__queryRemove(const Thing* thing, uint32_t count, uint32_t flags, Creature*) const { int32_t index = __getIndexOfThing(thing); if(index == -1) return RET_NOTPOSSIBLE; const Item* item = thing->getItem(); if(!item) return RET_NOTPOSSIBLE; if(!count || (item->isStackable() && count > item->getItemCount())) return RET_NOTPOSSIBLE; if(!item->isMovable() && !hasBitSet(FLAG_IGNORENOTMOVABLE, flags)) return RET_NOTMOVABLE; return RET_NOERROR; } Cylinder* Player::__queryDestination(int32_t& index, const Thing* thing, Item** destItem, uint32_t& flags) { if(!index /*drop to capacity window*/ || index == INDEX_WHEREEVER) { *destItem = NULL; const Item* item = thing->getItem(); if(!item) return this; bool autoStack = (flags & FLAG_IGNOREAUTOSTACK) != FLAG_IGNOREAUTOSTACK; if((!autoStack || !item->isStackable()) && backpack.first && backpack.first->__queryAdd(backpack.second, item, item->getItemCount(), flags)) { index = backpack.second; if(backpack.second != INDEX_WHEREEVER) ++backpack.second; return backpack.first; } std::list<std::pair<Container*, int32_t> > containers; std::list<std::pair<Cylinder*, int32_t> > freeSlots; for(int32_t i = SLOT_FIRST; i < SLOT_LAST; ++i) { if(Item* invItem = inventory[i]) { if(invItem == item || invItem == tradeItem) continue; if(autoStack && item->isStackable() && __queryAdd(i, item, item->getItemCount(), 0) == RET_NOERROR && invItem->getID() == item->getID() && invItem->getItemCount() < 100) { *destItem = invItem; index = i; return this; } if(Container* container = invItem->getContainer()) { if(!autoStack && container->__queryAdd( INDEX_WHEREEVER, item, item->getItemCount(), flags) == RET_NOERROR) { index = INDEX_WHEREEVER; backpack = std::make_pair(container, index + 1); return container; } containers.push_back(std::make_pair(container, 0)); } } else if(!autoStack) { if(__queryAdd(i, item, item->getItemCount(), 0) == RET_NOERROR) { index = i; return this; } } else freeSlots.push_back(std::make_pair(this, i)); } int32_t deepness = g_config.getNumber(ConfigManager::PLAYER_DEEPNESS); while(!containers.empty()) { Container* tmpContainer = containers.front().first; int32_t level = containers.front().second; containers.pop_front(); if(!tmpContainer) continue; for(uint32_t n = 0; n < tmpContainer->capacity(); ++n) { if(Item* tmpItem = tmpContainer->getItem(n)) { if(tmpItem == item || tmpItem == tradeItem) continue; if(autoStack && item->isStackable() && tmpContainer->__queryAdd(n, item, item->getItemCount(), 0) == RET_NOERROR && tmpItem->getID() == item->getID() && tmpItem->getItemCount() < 100) { index = n; *destItem = tmpItem; return tmpContainer; } if(Container* container = tmpItem->getContainer()) { if(!autoStack && container->__queryAdd(INDEX_WHEREEVER, item, item->getItemCount(), flags) == RET_NOERROR) { index = INDEX_WHEREEVER; backpack = std::make_pair(container, index + 1); return container; } if(deepness < 0 || level < deepness) containers.push_back(std::make_pair(container, level + 1)); } } else { if(!autoStack) { if(tmpContainer->__queryAdd(n, item, item->getItemCount(), 0) == RET_NOERROR) { index = n; backpack = std::make_pair(tmpContainer, index + 1); return tmpContainer; } } else freeSlots.push_back(std::make_pair(tmpContainer, n)); break; // one slot to check is definitely enough. } } } if(autoStack) { while(!freeSlots.empty()) { Cylinder* tmpCylinder = freeSlots.front().first; int32_t i = freeSlots.front().second; freeSlots.pop_front(); if(!tmpCylinder) continue; if(tmpCylinder->__queryAdd(i, item, item->getItemCount(), flags) == RET_NOERROR) { index = i; return tmpCylinder; } } } return this; } Thing* destThing = __getThing(index); if(destThing) *destItem = destThing->getItem(); if(Cylinder* subCylinder = dynamic_cast<Cylinder*>(destThing)) { index = INDEX_WHEREEVER; *destItem = NULL; return subCylinder; } return this; } void Player::__addThing(Creature* actor, Thing* thing) { __addThing(actor, 0, thing); } void Player::__addThing(Creature*, int32_t index, Thing* thing) { if(index < 0 || index > 11) { #ifdef __DEBUG_MOVESYS__ std::clog << "Failure: [Player::__addThing], " << "player: " << getName() << ", index: " << index << ", index < 0 || index > 11" << std::endl; #endif return /*RET_NOTPOSSIBLE*/; } if(!index) { #ifdef __DEBUG_MOVESYS__ std::clog << "Failure: [Player::__addThing], " << "player: " << getName() << ", index == 0" << std::endl; #endif return /*RET_NOTENOUGHROOM*/; } Item* item = thing->getItem(); if(!item) { #ifdef __DEBUG_MOVESYS__ std::clog << "Failure: [Player::__addThing], " << "player: " << getName() << ", item == NULL" << std::endl; #endif return /*RET_NOTPOSSIBLE*/; } item->setParent(this); inventory[index] = item; //send to client sendAddInventoryItem((slots_t)index, item); //event methods onAddInventoryItem((slots_t)index, item); } void Player::__updateThing(Thing* thing, uint16_t itemId, uint32_t count) { int32_t index = __getIndexOfThing(thing); if(index == -1) { #ifdef __DEBUG_MOVESYS__ std::clog << "Failure: [Player::__updateThing], " << "player: " << getName() << ", index == -1" << std::endl; #endif return /*RET_NOTPOSSIBLE*/; } Item* item = thing->getItem(); if(!item) { #ifdef __DEBUG_MOVESYS__ std::clog << "Failure: [Player::__updateThing], " << "player: " << getName() << ", item == NULL" << std::endl; #endif return /*RET_NOTPOSSIBLE*/; } const ItemType& oldType = Item::items[item->getID()]; const ItemType& newType = Item::items[itemId]; item->setID(itemId); item->setSubType(count); //send to client sendUpdateInventoryItem((slots_t)index, item, item); //event methods onUpdateInventoryItem((slots_t)index, item, oldType, item, newType); } void Player::__replaceThing(uint32_t index, Thing* thing) { if(index > 11) { #ifdef __DEBUG_MOVESYS__ std::clog << "Failure: [Player::__replaceThing], " << "player: " << getName() << ", index: " << index << ", index < 0 || index > 11" << std::endl; #endif return /*RET_NOTPOSSIBLE*/; } Item* oldItem = getInventoryItem((slots_t)index); if(!oldItem) { #ifdef __DEBUG_MOVESYS__ std::clog << "Failure: [Player::__updateThing], " << "player: " << getName() << ", oldItem == NULL" << std::endl; #endif return /*RET_NOTPOSSIBLE*/; } Item* item = thing->getItem(); if(!item) { #ifdef __DEBUG_MOVESYS__ std::clog << "Failure: [Player::__updateThing], " << "player: " << getName() << ", item == NULL" << std::endl; #endif return /*RET_NOTPOSSIBLE*/; } const ItemType& oldType = Item::items[oldItem->getID()]; const ItemType& newType = Item::items[item->getID()]; //send to client sendUpdateInventoryItem((slots_t)index, oldItem, item); //event methods onUpdateInventoryItem((slots_t)index, oldItem, oldType, item, newType); item->setParent(this); inventory[index] = item; } void Player::__removeThing(Thing* thing, uint32_t count) { Item* item = thing->getItem(); if(!item) { #ifdef __DEBUG_MOVESYS__ std::clog << "Failure: [Player::__removeThing], " << "player: " << getName() << ", item == NULL" << std::endl; #endif return /*RET_NOTPOSSIBLE*/; } int32_t index = __getIndexOfThing(thing); if(index == -1) { #ifdef __DEBUG_MOVESYS__ std::clog << "Failure: [Player::__removeThing], " << "player: " << getName() << ", index == -1" << std::endl; #endif return /*RET_NOTPOSSIBLE*/; } if(item->isStackable()) { if(count == item->getItemCount()) { //send change to client sendRemoveInventoryItem((slots_t)index, item); //event methods onRemoveInventoryItem((slots_t)index, item); item->setParent(NULL); inventory[index] = NULL; } else { item->setItemCount(std::max(0, (int32_t)(item->getItemCount() - count))); const ItemType& it = Item::items[item->getID()]; //send change to client sendUpdateInventoryItem((slots_t)index, item, item); //event methods onUpdateInventoryItem((slots_t)index, item, it, item, it); } } else { //send change to client sendRemoveInventoryItem((slots_t)index, item); //event methods onRemoveInventoryItem((slots_t)index, item); item->setParent(NULL); inventory[index] = NULL; } } Thing* Player::__getThing(uint32_t index) const { if(index > SLOT_PRE_FIRST && index < SLOT_LAST) return inventory[index]; return NULL; } int32_t Player::__getIndexOfThing(const Thing* thing) const { for(int32_t i = SLOT_FIRST; i < SLOT_LAST; ++i) { if(inventory[i] == thing) return i; } return -1; } int32_t Player::__getFirstIndex() const { return SLOT_FIRST; } int32_t Player::__getLastIndex() const { return SLOT_LAST; } uint32_t Player::__getItemTypeCount(uint16_t itemId, int32_t subType /*= -1*/) const { Item* item = NULL; Container* container = NULL; uint32_t count = 0; for(int32_t i = SLOT_FIRST; i < SLOT_LAST; ++i) { if(!(item = inventory[i])) continue; if(item->getID() == itemId) count += Item::countByType(item, subType); if(!(container = item->getContainer())) continue; for(ContainerIterator it = container->begin(), end = container->end(); it != end; ++it) { if((*it)->getID() == itemId) count += Item::countByType(*it, subType); } } return count; } std::map<uint32_t, uint32_t>& Player::__getAllItemTypeCount(std::map<uint32_t, uint32_t>& countMap) const { Item* item = NULL; Container* container = NULL; for(int32_t i = SLOT_FIRST; i < SLOT_LAST; ++i) { if(!(item = inventory[i])) continue; countMap[item->getID()] += Item::countByType(item, -1); if(!(container = item->getContainer())) continue; for(ContainerIterator it = container->begin(), end = container->end(); it != end; ++it) countMap[(*it)->getID()] += Item::countByType(*it, -1); } return countMap; } void Player::postAddNotification(Creature*, Thing* thing, const Cylinder* oldParent, int32_t index, CylinderLink_t link /*= LINK_OWNER*/) { if(link == LINK_OWNER) //calling movement scripts g_moveEvents->onPlayerEquip(this, thing->getItem(), (slots_t)index, false); bool requireListUpdate = true; if(link == LINK_OWNER || link == LINK_TOPPARENT) { if(const Item* item = (oldParent ? oldParent->getItem() : NULL)) { assert(item->getContainer() != NULL); requireListUpdate = item->getContainer()->getHoldingPlayer() != this; } else requireListUpdate = oldParent != this; updateInventoryWeight(); updateItemsLight(); updateWeapon(); sendStats(); } if(const Item* item = thing->getItem()) { if(const Container* container = item->getContainer()) onSendContainer(container); if(shopOwner && requireListUpdate) updateInventoryGoods(item->getID()); } else if(const Creature* creature = thing->getCreature()) { if(creature != this) return; std::vector<Container*> containers; for(ContainerVector::iterator it = containerVec.begin(); it != containerVec.end(); ++it) { if(!Position::areInRange<1,1,0>(it->second->getPosition(), getPosition())) containers.push_back(it->second); } for(std::vector<Container*>::const_iterator it = containers.begin(); it != containers.end(); ++it) autoCloseContainers(*it); } } void Player::postRemoveNotification(Creature*, Thing* thing, const Cylinder* newParent, int32_t index, bool isCompleteRemoval, CylinderLink_t link/* = LINK_OWNER*/) { if(link == LINK_OWNER) //calling movement scripts g_moveEvents->onPlayerDeEquip(this, thing->getItem(), (slots_t)index, isCompleteRemoval); bool requireListUpdate = true; if(link == LINK_OWNER || link == LINK_TOPPARENT) { if(const Item* item = (newParent ? newParent->getItem() : NULL)) { assert(item->getContainer() != NULL); requireListUpdate = item->getContainer()->getHoldingPlayer() == this; } else requireListUpdate = newParent == this; updateInventoryWeight(); updateItemsLight(); updateWeapon(); sendStats(); } if(const Item* item = thing->getItem()) { if(const Container* container = item->getContainer()) { if(container->isRemoved() || !Position::areInRange<1,1,0>(getPosition(), container->getPosition())) autoCloseContainers(container); else if(container->getTopParent() == this) onSendContainer(container); else if(const Container* topContainer = dynamic_cast<const Container*>(container->getTopParent())) { if(const DepotChest* depotChest = dynamic_cast<const DepotChest*>(topContainer)) { bool isOwner = false; for(DepotMap::iterator it = depotChests.begin(); it != depotChests.end(); ++it) { if(it->second == depotChest) { isOwner = true; onSendContainer(container); } } if(!isOwner) autoCloseContainers(container); } else onSendContainer(container); } else autoCloseContainers(container); } if(shopOwner && requireListUpdate) updateInventoryGoods(item->getID()); } } void Player::__internalAddThing(Thing* thing) { __internalAddThing(0, thing); } void Player::__internalAddThing(uint32_t index, Thing* thing) { #ifdef __DEBUG_MOVESYS__ std::clog << "[Player::__internalAddThing] index: " << index << std::endl; #endif if(!index || index > 11) { #ifdef __DEBUG_MOVESYS__ std::clog << "Failure: [Player::__internalAddThing] index == 0 || index > 11" << std::endl; #endif return; } if(inventory[index]) { #ifdef __DEBUG_MOVESYS__ std::clog << "Warning: [Player::__internalAddThing], player: " << getName() << ", items[index] is not empty." << std::endl; #endif return; } Item* item = thing->getItem(); if(!item) { #ifdef __DEBUG_MOVESYS__ std::clog << "Failure: [Player::__internalAddThing] item == NULL" << std::endl; #endif return; } inventory[index] = item; item->setParent(this); } bool Player::setFollowCreature(Creature* creature, bool fullPathSearch /*= false*/) { bool deny = false; CreatureEventList followEvents = getCreatureEvents(CREATURE_EVENT_FOLLOW); for(CreatureEventList::iterator it = followEvents.begin(); it != followEvents.end(); ++it) { if(!(*it)->executeAction(this, creature) && !deny) deny = true; } if(deny || Creature::setFollowCreature(creature, fullPathSearch)) return true; setFollowCreature(NULL); setAttackedCreature(NULL); if(!deny) sendCancelMessage(RET_THEREISNOWAY); sendCancelTarget(); cancelNextWalk = true; return false; } bool Player::setAttackedCreature(Creature* creature) { if(!Creature::setAttackedCreature(creature)) { sendCancelTarget(); return false; } if(chaseMode == CHASEMODE_FOLLOW && creature && !getNoMove()) { if(followCreature != creature) //chase opponent setFollowCreature(creature); } else setFollowCreature(NULL); if(creature) Dispatcher::getInstance().addTask(createTask(boost::bind(&Game::checkCreatureAttack, &g_game, getID()))); return true; } void Player::goToFollowCreature() { if(!walkTask) Creature::goToFollowCreature(); } void Player::getPathSearchParams(const Creature* creature, FindPathParams& fpp) const { Creature::getPathSearchParams(creature, fpp); fpp.fullPathSearch = true; } void Player::doAttacking(uint32_t) { if(!lastAttack) lastAttack = OTSYS_TIME() - getAttackSpeed() - 1; else if((OTSYS_TIME() - lastAttack) < getAttackSpeed()) return; if(hasCondition(CONDITION_PACIFIED) && !hasCustomFlag(PlayerCustomFlag_IgnorePacification)) { lastAttack = OTSYS_TIME(); return; } Item* item = getWeapon(false); if(const Weapon* _weapon = g_weapons->getWeapon(item)) { if(_weapon->interruptSwing() && !canDoAction()) { SchedulerTask* task = createSchedulerTask(getNextActionTime(), boost::bind(&Game::checkCreatureAttack, &g_game, getID())); setNextActionTask(task); } else { if((!_weapon->hasExhaustion() || !hasCondition(CONDITION_EXHAUST)) && _weapon->useWeapon(this, item, attackedCreature)) lastAttack = OTSYS_TIME(); updateWeapon(); } } else if(Weapon::useFist(this, attackedCreature)) lastAttack = OTSYS_TIME(); } double Player::getGainedExperience(Creature* attacker) const { if(!skillLoss) return 0; double rate = g_config.getDouble(ConfigManager::RATE_PVP_EXPERIENCE); if(rate <= 0) return 0; Player* attackerPlayer = attacker->getPlayer(); if(!attackerPlayer || attackerPlayer == this) return 0; double attackerLevel = (double)attackerPlayer->getLevel(), min = g_config.getDouble( ConfigManager::EFP_MIN_THRESHOLD), max = g_config.getDouble(ConfigManager::EFP_MAX_THRESHOLD); if((min > 0.0 && level < (uint32_t)std::floor(attackerLevel * min)) || (max > 0.0 && level > (uint32_t)std::floor(attackerLevel * max))) return 0; /* Formula a = attackers level * 0.9 b = victims level c = victims experience result = (1 - (a / b)) * 0.05 * c Not affected by special multipliers(!) */ uint32_t a = (uint32_t)std::floor(attackerLevel * 0.9), b = level; uint64_t c = getExperience(); return (double)std::max((uint64_t)0, (uint64_t)std::floor(getDamageRatio(attacker) * std::max((double)0, ((double)(1 - (((double)a / b))))) * 0.05 * c)) * rate; } void Player::onFollowCreature(const Creature* creature) { if(!creature) cancelNextWalk = true; } void Player::setChaseMode(chaseMode_t mode) { if(chaseMode == mode) return; chaseMode = mode; if(chaseMode == CHASEMODE_FOLLOW) { if(!followCreature && attackedCreature && !getNoMove()) //chase opponent setFollowCreature(attackedCreature); } else if(attackedCreature) { setFollowCreature(NULL); cancelNextWalk = true; } } void Player::onWalkAborted() { setNextWalkActionTask(NULL); sendCancelWalk(); } void Player::onWalkComplete() { if(!walkTask) return; walkTaskEvent = Scheduler::getInstance().addEvent(walkTask); walkTask = NULL; } void Player::getCreatureLight(LightInfo& light) const { if(hasCustomFlag(PlayerCustomFlag_HasFullLight)) { light.level = 0xFF; light.color = 215; } else if(internalLight.level > itemsLight.level) light = internalLight; else light = itemsLight; } void Player::updateItemsLight(bool internal/* = false*/) { LightInfo maxLight, curLight; Item* item = NULL; for(int32_t i = SLOT_FIRST; i < SLOT_LAST; ++i) { if(!(item = getInventoryItem((slots_t)i))) continue; item->getLight(curLight); if(curLight.level > maxLight.level) maxLight = curLight; } if(maxLight.level != itemsLight.level || maxLight.color != itemsLight.color) { itemsLight = maxLight; if(!internal) g_game.changeLight(this); } } void Player::onAddCondition(ConditionType_t type, bool hadCondition) { Creature::onAddCondition(type, hadCondition); if(type == CONDITION_GAMEMASTER) return; if(type == CONDITION_INVISIBLE && !hadCondition && mounted) dismount(false); if(getLastPosition().x) // don't send if player have just logged in (its already done in protocolgame), or condition have no icons sendIcons(); } void Player::onAddCombatCondition(ConditionType_t type, bool) { std::string tmp; switch(type) { //client hardcoded case CONDITION_FIRE: tmp = "burning"; break; case CONDITION_POISON: tmp = "poisoned"; break; case CONDITION_ENERGY: tmp = "electrified"; break; case CONDITION_FREEZING: tmp = "freezing"; break; case CONDITION_DAZZLED: tmp = "dazzled"; break; case CONDITION_CURSED: tmp = "cursed"; break; case CONDITION_DROWN: tmp = "drowning"; break; case CONDITION_DRUNK: tmp = "drunk"; break; case CONDITION_PARALYZE: tmp = "paralyzed"; break; case CONDITION_BLEEDING: tmp = "bleeding"; break; default: break; } if(!tmp.empty()) sendTextMessage(MSG_STATUS_DEFAULT, "You are " + tmp + "."); } void Player::onEndCondition(ConditionType_t type) { Creature::onEndCondition(type); if(type == CONDITION_INFIGHT) { onIdleStatus(); clearAttacked(); pzLocked = false; if(skull < SKULL_RED) setSkull(SKULL_NONE); g_game.updateCreatureSkull(this); } sendIcons(); } void Player::onCombatRemoveCondition(const Creature*, Condition* condition) { //Creature::onCombatRemoveCondition(attacker, condition); bool remove = true; if(condition->getId() > 0) { remove = false; //Means the condition is from an item, id == slot if(g_game.getWorldType() == WORLDTYPE_HARDCORE) { if(Item* item = getInventoryItem((slots_t)condition->getId())) { //25% chance to destroy the item if(random_range(1, 100) < 26) g_game.internalRemoveItem(NULL, item); } } } if(remove) { if(!canDoAction()) { int32_t delay = getNextActionTime(false); delay -= (delay % EVENT_CREATURE_THINK_INTERVAL); if(delay < 0) removeCondition(condition); else condition->setTicks(delay); } else removeCondition(condition); } } void Player::onTickCondition(ConditionType_t type, int32_t interval, bool& _remove) { Creature::onTickCondition(type, interval, _remove); if(type == CONDITION_HUNTING) useStamina(-(interval * g_config.getNumber(ConfigManager::RATE_STAMINA_LOSS))); } void Player::onTarget(Creature* target) { Creature::onTarget(target); if(hasFlag(PlayerFlag_NotGainInFight)) return; if(target == this) { addInFightTicks(false); return; } Player* targetPlayer = target->getPlayer(); if(targetPlayer && !isPartner(targetPlayer) && !isAlly(targetPlayer)) { if(!pzLocked && g_game.getWorldType() == WORLDTYPE_HARDCORE) { pzLocked = true; sendIcons(); } if(getSkull() == SKULL_NONE && getSkullType(targetPlayer) == SKULL_YELLOW) { addAttacked(targetPlayer); targetPlayer->sendCreatureSkull(this); } else if(!targetPlayer->hasAttacked(this) && !targetPlayer->isEnemy(this, false)) { if(!pzLocked && g_game.getWorldType() != WORLDTYPE_HARDCORE) { pzLocked = true; sendIcons(); } if(!Combat::isInPvpZone(this, targetPlayer) && !isAlly(targetPlayer)) { addAttacked(targetPlayer); if(targetPlayer->getSkull() == SKULL_NONE && getSkull() == SKULL_NONE) { setSkull(SKULL_WHITE); g_game.updateCreatureSkull(this); } if(getSkull() == SKULL_NONE) targetPlayer->sendCreatureSkull(this); } } } addInFightTicks(false); } void Player::onSummonTarget(Creature* summon, Creature* target) { Creature::onSummonTarget(summon, target); onTarget(target); } void Player::onAttacked() { Creature::onAttacked(); addInFightTicks(false); } bool Player::checkLoginDelay() const { return (!hasCustomFlag(PlayerCustomFlag_IgnoreLoginDelay) && OTSYS_TIME() <= (lastLoad + g_config.getNumber( ConfigManager::LOGIN_PROTECTION))); } void Player::onIdleStatus() { Creature::onIdleStatus(); if(party) party->clearPlayerPoints(this); } void Player::onPlacedCreature() { //scripting event - onLogin if(!g_creatureEvents->playerLogin(this)) kick(true, true); } void Player::onTargetDrain(Creature* target, int32_t points) { if(points < 0) return; Creature::onTargetDrain(target, points); if(party && target && (!target->getMaster() || !target->getMaster()->getPlayer()) && target->getMonster() && target->getMonster()->isHostile()) //we have fulfilled a requirement for shared experience party->addPlayerDamageMonster(this, points); } void Player::onSummonTargetDrain(Creature* summon, Creature* target, int32_t points) { if(points < 0) return; Creature::onSummonTargetDrain(summon, target, points); if(party && target && (!target->getMaster() || !target->getMaster()->getPlayer()) && target->getMonster() && target->getMonster()->isHostile()) //we have fulfilled a requirement for shared experience party->addPlayerDamageMonster(this, points); } void Player::onTargetGain(Creature* target, int32_t points) { Creature::onTargetGain(target, points); if(!target || !party) return; Player* tmpPlayer = NULL; if(target->getPlayer()) tmpPlayer = target->getPlayer(); else if(target->getMaster() && target->getMaster()->getPlayer()) tmpPlayer = target->getMaster()->getPlayer(); if(isPartner(tmpPlayer)) party->addPlayerHealedMember(this, points); } void Player::onUpdateQuest() { sendTextMessage(MSG_EVENT_ADVANCE, "Your quest log has been updated."); } GuildEmblems_t Player::getGuildEmblem(const Creature* creature) const { const Player* player = creature->getPlayer(); if(!player || !player->hasEnemy()) return Creature::getGuildEmblem(creature); if(player->isEnemy(this, false)) return GUILDEMBLEM_ENEMY; return player->getGuildId() == guildId ? GUILDEMBLEM_ALLY : GUILDEMBLEM_NEUTRAL; } bool Player::getEnemy(const Player* player, War_t& data) const { if(!guildId || !player || player->isRemoved()) return false; uint32_t guild = player->getGuildId(); if(!guild) return false; WarMap::const_iterator it = warMap.find(guild); if(it == warMap.end()) return false; data = it->second; return true; } bool Player::isEnemy(const Player* player, bool allies) const { if(!guildId || !player || player->isRemoved()) return false; uint32_t guild = player->getGuildId(); if(!guild) return false; return !warMap.empty() && (((g_game.getWorldType() != WORLDTYPE_OPTIONAL || g_config.getBool( ConfigManager::OPTIONAL_WAR_ATTACK_ALLY)) && allies && guildId == guild) || warMap.find(guild) != warMap.end()); } bool Player::isAlly(const Player* player) const { return !warMap.empty() && player && player->getGuildId() == guildId; } bool Player::onKilledCreature(Creature* target, DeathEntry& entry) { if(!Creature::onKilledCreature(target, entry)) return false; if(hasFlag(PlayerFlag_NotGenerateLoot)) target->setDropLoot(LOOT_DROP_NONE); Condition* condition = NULL; if(target->getMonster() && !target->isPlayerSummon() && !hasFlag(PlayerFlag_HasInfiniteStamina) && (condition = Condition::createCondition(CONDITIONID_DEFAULT, CONDITION_HUNTING, g_config.getNumber(ConfigManager::HUNTING_DURATION)))) addCondition(condition); if(hasFlag(PlayerFlag_NotGainInFight) || getZone() != target->getZone()) return true; Player* targetPlayer = target->getPlayer(); if(!targetPlayer || Combat::isInPvpZone(this, targetPlayer) || isPartner(targetPlayer) || isAlly(targetPlayer)) return true; War_t enemy; if(targetPlayer->getEnemy(this, enemy)) { if(entry.isLast()) IOGuild::getInstance()->updateWar(enemy); entry.setWar(enemy); } if(!entry.isJustify() || !hasCondition(CONDITION_INFIGHT)) return true; std::vector<uint32_t>::iterator it = std::find(revengeList.begin(), revengeList.end(), targetPlayer->getGUID()); if(!targetPlayer->hasAttacked(this) && target->getSkull() == SKULL_NONE && it == revengeList.end() && targetPlayer != this && (addUnjustifiedKill(targetPlayer, !enemy.war) || entry.isLast())) entry.setUnjustified(); if(it != revengeList.end()) revengeList.erase(it); addInFightTicks(true, g_config.getNumber(ConfigManager::WHITE_SKULL_TIME)); return true; } bool Player::gainExperience(double& gainExp, Creature* target) { if(!rateExperience(gainExp, target)) return false; //soul regeneration if(gainExp >= level) { if(Condition* condition = Condition::createCondition( CONDITIONID_DEFAULT, CONDITION_SOUL, 4 * 60 * 1000)) { condition->setParam(CONDITIONPARAM_SOULGAIN, vocation->getGainAmount(GAIN_SOUL)); condition->setParam(CONDITIONPARAM_SOULTICKS, (vocation->getGainTicks(GAIN_SOUL) * 1000)); addCondition(condition); } } addExperience((uint64_t)gainExp); return true; } bool Player::rateExperience(double& gainExp, Creature* target) { if(hasFlag(PlayerFlag_NotGainExperience) || gainExp <= 0) return false; if(target->getPlayer()) return true; gainExp *= rates[SKILL__LEVEL] * g_game.getExperienceStage(level, vocation->getExperienceMultiplier()); if(!hasFlag(PlayerFlag_HasInfiniteStamina)) { int32_t minutes = getStaminaMinutes(); if(minutes >= g_config.getNumber(ConfigManager::STAMINA_LIMIT_TOP)) { if(isPremium() || !g_config.getBool(ConfigManager::STAMINA_BONUS_PREMIUM)) gainExp *= g_config.getDouble(ConfigManager::RATE_STAMINA_ABOVE); } else if(minutes < (g_config.getNumber(ConfigManager::STAMINA_LIMIT_BOTTOM)) && minutes > 0) gainExp *= g_config.getDouble(ConfigManager::RATE_STAMINA_UNDER); else if(minutes <= 0) gainExp = 0; } else if(isPremium() || !g_config.getBool(ConfigManager::STAMINA_BONUS_PREMIUM)) gainExp *= g_config.getDouble(ConfigManager::RATE_STAMINA_ABOVE); return true; } void Player::onGainExperience(double& gainExp, Creature* target, bool multiplied) { uint64_t tmp = experience; if(party && party->isSharedExperienceEnabled() && party->isSharedExperienceActive()) { party->shareExperience(gainExp, target, multiplied); rateExperience(gainExp, target); return; //we will get a share of the experience through the sharing mechanism } if(gainExperience(gainExp, target)) Creature::onGainExperience(gainExp, target, true); CreatureEventList advanceEvents = getCreatureEvents(CREATURE_EVENT_ADVANCE); for(CreatureEventList::iterator it = advanceEvents.begin(); it != advanceEvents.end(); ++it) (*it)->executeAdvance(this, SKILL__EXPERIENCE, tmp, experience); } void Player::onGainSharedExperience(double& gainExp, Creature* target, bool) { if(gainExperience(gainExp, target)) Creature::onGainSharedExperience(gainExp, target, true); } bool Player::isImmune(CombatType_t type) const { return hasCustomFlag(PlayerCustomFlag_IsImmune) || Creature::isImmune(type); } bool Player::isImmune(ConditionType_t type) const { return hasCustomFlag(PlayerCustomFlag_IsImmune) || Creature::isImmune(type); } bool Player::isProtected() const { return (vocation && !vocation->isAttackable()) || hasCustomFlag(PlayerCustomFlag_IsProtected) || level < g_config.getNumber(ConfigManager::PROTECTION_LEVEL); } bool Player::isAttackable() const { return !hasFlag(PlayerFlag_CannotBeAttacked) && !isAccountManager(); } void Player::changeHealth(int32_t healthChange) { Creature::changeHealth(healthChange); sendStats(); } void Player::changeMana(int32_t manaChange) { if(!hasFlag(PlayerFlag_HasInfiniteMana)) Creature::changeMana(manaChange); sendStats(); } void Player::changeSoul(int32_t soulChange) { if(!hasFlag(PlayerFlag_HasInfiniteSoul)) soul = std::min((int32_t)soulMax, (int32_t)soul + soulChange); sendStats(); } bool Player::changeOutfit(Outfit_t outfit, bool checkList) { uint32_t outfitId = Outfits::getInstance()->getOutfitId(outfit.lookType); if(checkList && (!canWearOutfit(outfitId, outfit.lookAddons) || !requestedOutfit)) return false; if(outfit.lookMount && outfit.lookMount != getDefaultOutfit().lookMount) { Mount* mount = Mounts::getInstance()->getMountByCid(outfit.lookMount); if(!mount || !mount->isTamed(this)) return false; } requestedOutfit = false; if(outfitAttributes) { uint32_t oldId = Outfits::getInstance()->getOutfitId(defaultOutfit.lookType); outfitAttributes = !Outfits::getInstance()->removeAttributes(getID(), oldId, sex); } defaultOutfit = outfit; outfitAttributes = Outfits::getInstance()->addAttributes(getID(), outfitId, sex, defaultOutfit.lookAddons); return true; } bool Player::canWearOutfit(uint32_t outfitId, uint32_t addons) { OutfitMap::iterator it = outfits.find(outfitId); if(it == outfits.end() || (it->second.isPremium && !isPremium()) || getAccess() < it->second.accessLevel || (!it->second.groups.empty() && std::find(it->second.groups.begin(), it->second.groups.end(), groupId) == it->second.groups.end()) || ((it->second.addons & addons) != addons && !hasCustomFlag(PlayerCustomFlag_CanWearAllAddons))) return false; if(it->second.storageId.empty()) return true; std::string value; getStorage(it->second.storageId, value); if(value == it->second.storageValue) return true; int32_t intValue = atoi(value.c_str()); if(!intValue && value != "0") return false; int32_t tmp = atoi(it->second.storageValue.c_str()); if(!tmp && it->second.storageValue != "0") return false; return intValue >= tmp; } bool Player::addOutfit(uint32_t outfitId, uint32_t addons) { Outfit outfit; if(!Outfits::getInstance()->getOutfit(outfitId, sex, outfit)) return false; OutfitMap::iterator it = outfits.find(outfitId); if(it != outfits.end()) outfit.addons |= it->second.addons; outfit.addons |= addons; outfits[outfitId] = outfit; return true; } bool Player::removeOutfit(uint32_t outfitId, uint32_t addons) { OutfitMap::iterator it = outfits.find(outfitId); if(it == outfits.end()) return false; bool update = false; if(addons == 0xFF) //remove outfit { if(it->second.lookType == defaultOutfit.lookType) { outfits.erase(it); if((it = outfits.begin()) != outfits.end()) defaultOutfit.lookType = it->second.lookType; update = true; } else outfits.erase(it); } else //remove addons { update = it->second.lookType == defaultOutfit.lookType; it->second.addons &= ~addons; } if(update) g_game.internalCreatureChangeOutfit(this, defaultOutfit, true); return true; } void Player::generateReservedStorage() { uint32_t key = PSTRG_OUTFITSID_RANGE_START + 1; const OutfitMap& defaultOutfits = Outfits::getInstance()->getOutfits(sex); for(OutfitMap::const_iterator it = outfits.begin(); it != outfits.end(); ++it) { OutfitMap::const_iterator dit = defaultOutfits.find(it->first); if(dit == defaultOutfits.end() || (dit->second.isDefault && (dit->second.addons & it->second.addons) == it->second.addons)) continue; std::stringstream k, v; k << key++; // this may not work as intended, revalidate it v << ((it->first << 16) | (it->second.addons & 0xFF)); storageMap[k.str()] = v.str(); if(key <= PSTRG_OUTFITSID_RANGE_START + PSTRG_OUTFITSID_RANGE_SIZE) continue; std::clog << "[Warning - Player::genReservedStorageRange] Player " << getName() << " with more than 500 outfits!" << std::endl; break; } } void Player::setSex(uint16_t newSex) { sex = newSex; const OutfitMap& defaultOutfits = Outfits::getInstance()->getOutfits(sex); for(OutfitMap::const_iterator it = defaultOutfits.begin(); it != defaultOutfits.end(); ++it) { if(it->second.isDefault) addOutfit(it->first, it->second.addons); } } Skulls_t Player::getSkull() const { if(hasFlag(PlayerFlag_NotGainInFight) || hasCustomFlag(PlayerCustomFlag_NotGainSkull)) return SKULL_NONE; return skull; } Skulls_t Player::getSkullType(const Creature* creature) const { const Player* player = creature->getPlayer(); if(player && player->getSkull() == SKULL_NONE) { if(g_game.getWorldType() != WORLDTYPE_OPEN) return SKULL_NONE; if(player->canRevenge(guid) && player->hasAttacked(this) && !player->isEnemy(this, false)) return SKULL_YELLOW; if((isPartner(player) || isAlly(player)) && g_game.getWorldType() != WORLDTYPE_OPTIONAL) return SKULL_GREEN; if(canRevenge(player->getGUID())) return SKULL_ORANGE; } return Creature::getSkullType(creature); } bool Player::hasAttacked(const Player* attacked) const { return !hasFlag(PlayerFlag_NotGainInFight) && attacked && attackedSet.find(attacked->getID()) != attackedSet.end(); } void Player::addAttacked(const Player* attacked) { if(hasFlag(PlayerFlag_NotGainInFight) || !attacked) return; uint32_t attackedId = attacked->getID(); if(attackedSet.find(attackedId) == attackedSet.end()) attackedSet.insert(attackedId); } void Player::setSkullEnd(time_t _time, bool login, Skulls_t _skull) { if(g_game.getWorldType() != WORLDTYPE_OPEN || hasFlag(PlayerFlag_NotGainInFight) || hasCustomFlag(PlayerCustomFlag_NotGainSkull)) return; bool requireUpdate = false; if(_time > time(NULL)) { requireUpdate = true; setSkull(_skull); } else if(skull == _skull) { requireUpdate = true; setSkull(SKULL_NONE); _time = 0; } if(requireUpdate) { skullEnd = _time; if(!login) g_game.updateCreatureSkull(this); } } bool Player::addUnjustifiedKill(const Player* attacked, bool countNow) { if(!g_config.getBool(ConfigManager::USE_FRAG_HANDLER) || hasFlag( PlayerFlag_NotGainInFight) || g_game.getWorldType() != WORLDTYPE_OPEN || hasCustomFlag(PlayerCustomFlag_NotGainUnjustified) || hasCustomFlag( PlayerCustomFlag_NotGainSkull) || attacked == this) return false; if(countNow) { char buffer[90]; sprintf(buffer, "Warning! The murder of %s was not justified.", attacked->getName().c_str()); sendTextMessage(MSG_STATUS_WARNING, buffer); } time_t now = time(NULL), first = (now - g_config.getNumber(ConfigManager::FRAG_LIMIT)), second = (now - g_config.getNumber(ConfigManager::FRAG_SECOND_LIMIT)); std::vector<time_t> dateList; IOLoginData::getInstance()->getUnjustifiedDates(guid, dateList, now); if(countNow) dateList.push_back(now); uint32_t fc = 0, sc = 0, tc = dateList.size(); for(std::vector<time_t>::iterator it = dateList.begin(); it != dateList.end(); ++it) { if(second > 0 && (*it) > second) sc++; if(first > 0 && (*it) > first) fc++; } uint32_t f = g_config.getNumber(ConfigManager::RED_LIMIT), s = g_config.getNumber( ConfigManager::RED_SECOND_LIMIT), t = g_config.getNumber(ConfigManager::RED_THIRD_LIMIT); if(skull < SKULL_RED && ((f > 0 && fc >= f) || (s > 0 && sc >= s) || (t > 0 && tc >= t))) setSkullEnd(now + g_config.getNumber(ConfigManager::RED_SKULL_LENGTH), false, SKULL_RED); if(!g_config.getBool(ConfigManager::USE_BLACK_SKULL)) { f += g_config.getNumber(ConfigManager::BAN_LIMIT); s += g_config.getNumber(ConfigManager::BAN_SECOND_LIMIT); t += g_config.getNumber(ConfigManager::BAN_THIRD_LIMIT); if((f <= 0 || fc < f) && (s <= 0 || sc < s) && (t <= 0 || tc < t)) return true; if(!IOBan::getInstance()->addAccountBanishment(accountId, (now + g_config.getNumber( ConfigManager::KILLS_BAN_LENGTH)), "Unjustified player killing.", 0, guid)) return true; sendTextMessage(MSG_INFO_DESCR, "You have been banished."); g_game.addMagicEffect(getPosition(), MAGIC_EFFECT_WRAPS_GREEN); Scheduler::getInstance().addEvent(createSchedulerTask(1000, boost::bind( &Game::kickPlayer, &g_game, getID(), false))); } else { f += g_config.getNumber(ConfigManager::BLACK_LIMIT); s += g_config.getNumber(ConfigManager::BLACK_SECOND_LIMIT); t += g_config.getNumber(ConfigManager::BLACK_THIRD_LIMIT); if(skull < SKULL_BLACK && ((f > 0 && fc >= f) || (s > 0 && sc >= s) || (t > 0 && tc >= t))) { setSkullEnd(now + g_config.getNumber(ConfigManager::BLACK_SKULL_LENGTH), false, SKULL_BLACK); setAttackedCreature(NULL); destroySummons(); } } return true; } void Player::setPromotionLevel(uint32_t pLevel) { if(pLevel > promotionLevel) { int32_t tmpLevel = 0, currentVoc = vocationId; for(uint32_t i = promotionLevel; i < pLevel; ++i) { currentVoc = Vocations::getInstance()->getPromotedVocation(currentVoc); if(currentVoc < 1) break; tmpLevel++; Vocation* voc = Vocations::getInstance()->getVocation(currentVoc); if(voc->isPremiumNeeded() && !isPremium() && g_config.getBool(ConfigManager::PREMIUM_FOR_PROMOTION)) continue; vocationId = currentVoc; } promotionLevel += tmpLevel; } else if(pLevel < promotionLevel) { uint32_t tmpLevel = 0, currentVoc = vocationId; for(uint32_t i = pLevel; i < promotionLevel; ++i) { Vocation* voc = Vocations::getInstance()->getVocation(currentVoc); if(voc->getFromVocation() == currentVoc) break; tmpLevel++; currentVoc = voc->getFromVocation(); if(voc->isPremiumNeeded() && !isPremium() && g_config.getBool(ConfigManager::PREMIUM_FOR_PROMOTION)) continue; vocationId = currentVoc; } promotionLevel -= tmpLevel; } setVocation(vocationId); } uint16_t Player::getBlessings() const { if(!g_config.getBool(ConfigManager::BLESSINGS) || (!isPremium() && g_config.getBool(ConfigManager::BLESSING_ONLY_PREMIUM))) return 0; uint16_t count = 0; for(int16_t i = 0; i < 16; ++i) { if(hasBlessing(i)) count++; } return count; } uint64_t Player::getLostExperience() const { double percent = (double)(lossPercent[LOSS_EXPERIENCE] - vocation->getLessLoss() - (getBlessings() * g_config.getNumber( ConfigManager::BLESS_REDUCTION))) / 100.; if(level <= 25) return (uint64_t)std::floor(percent * experience / 10.); int32_t base = level; double levels = (double)(base + 50) / 100.; uint64_t lost = 0; while(levels > 1.0f) { lost += (getExpForLevel(base) - getExpForLevel(base - 1)); base--; levels -= 1.; } if(levels > 0.) lost += (uint64_t)std::floor(levels * (getExpForLevel(base) - getExpForLevel(base - 1))); return (uint64_t)std::floor(percent * lost); } uint32_t Player::getAttackSpeed() const { int32_t modifiers = 0; if(mounted) { if(Mount* tmp = Mounts::getInstance()->getMountByCid(defaultOutfit.lookMount)) { if(tmp->getAttackSpeed() == -1) return 0; modifiers += tmp->getAttackSpeed(); } } if(outfitAttributes) { Outfit outfit; if(Outfits::getInstance()->getOutfit(defaultOutfit.lookType, outfit)) { if(outfit.attackSpeed == -1) return 0; modifiers += outfit.attackSpeed; } } Item* _weapon = weapon; if(!weapon || weapon->getWeaponType() == WEAPON_AMMO) _weapon = const_cast<Player*>(this)->getWeapon(true); //--- return (((_weapon && _weapon->getAttackSpeed() != 0) ? _weapon->getAttackSpeed() : (vocation->getAttackSpeed() / std::max((size_t)1, getWeapons().size()))) + modifiers); return (((weapon && weapon->getAttackSpeed() != 0) ? weapon->getAttackSpeed() * (1 - (getSkill(SKILL_FIST, SKILL_LEVEL) * 0.00475)) : (vocation->getAttackSpeed() / std::max((size_t)1, getWeapons().size()) * (1 - (getSkill(SKILL_FIST, SKILL_LEVEL) * 0.00475)))) + modifiers); //-- Mudei aqui } void Player::learnInstantSpell(const std::string& name) { if(!hasLearnedInstantSpell(name)) learnedInstantSpellList.push_back(name); } void Player::unlearnInstantSpell(const std::string& name) { if(!hasLearnedInstantSpell(name)) return; LearnedInstantSpellList::iterator it = std::find(learnedInstantSpellList.begin(), learnedInstantSpellList.end(), name); if(it != learnedInstantSpellList.end()) learnedInstantSpellList.erase(it); } bool Player::hasLearnedInstantSpell(const std::string& name) const { if(hasFlag(PlayerFlag_CannotUseSpells)) return false; if(hasFlag(PlayerFlag_IgnoreSpellCheck)) return true; for(LearnedInstantSpellList::const_iterator it = learnedInstantSpellList.begin(); it != learnedInstantSpellList.end(); ++it) { if(boost::algorithm::iequals(*it, name)) return true; } return false; } void Player::manageAccount(const std::string &text) { std::stringstream msg; bool noSwap = true; switch(accountManager) { case MANAGER_NAMELOCK: { if(!talkState[1]) { managerString = text; trimString(managerString); if(managerString.length() < 3) msg << "The name is too short, please select a longer one."; else if(managerString.length() > 30) msg << "The name is too long, please select a shorter one."; else if(!isValidName(managerString)) msg << "Your name seems to contain invalid symbols, please choose another one."; else if(IOLoginData::getInstance()->playerExists(managerString, true)) msg << "Player with that name already exists, please choose another one."; else { std::string tmp = asLowerCaseString(managerString); if(tmp.substr(0, 4) != "god " && tmp.substr(0, 3) != "cm " && tmp.substr(0, 3) != "gm ") { talkState[1] = talkState[2] = true; msg << "{" << managerString << "}, are you sure? {yes} or {no}?"; } else msg << "Your character is not a staff member, please choose another name."; } } else if(checkText(text, "no") && talkState[2]) { talkState[1] = talkState[2] = false; msg << "What new name would you like have then?"; } else if(checkText(text, "yes") && talkState[2]) { if(!IOLoginData::getInstance()->playerExists(managerString, true)) { uint32_t tmp; if(IOLoginData::getInstance()->getGuidByName(tmp, managerString2) && IOLoginData::getInstance()->changeName(tmp, managerString, managerString2) && IOBan::getInstance()->removePlayerBanishment(tmp, PLAYERBAN_LOCK)) { msg << "Your character {" << managerString << "} has been successfully renamed to {" << managerString2 << "}, you should be able to login now."; if(House* house = Houses::getInstance()->getHouseByPlayerId(tmp)) house->updateDoorDescription(managerString); talkState[1] = true; talkState[2] = false; } else { talkState[1] = talkState[2] = false; msg << "Failed to change your name, please contact with staff."; } } else { talkState[1] = talkState[2] = false; msg << "Player with that name already exists, please choose another one."; } } else msg << "Sorry, but I can't understand you, please try to repeat."; break; } case MANAGER_ACCOUNT: { Account account = IOLoginData::getInstance()->loadAccount(managerNumber); if(checkText(text, "cancel") || (checkText(text, "account") && !talkState[1])) { talkState[1] = true; for(int8_t i = 2; i <= 12; ++i) talkState[i] = false; msg << "Do you want to change your {password}, generate a {recovery key}, create a {character}, or {delete} an existing character?"; } else if(checkText(text, "delete") && talkState[1]) { talkState[1] = false; talkState[2] = true; msg << "Which character would you like to delete?"; } else if(talkState[2]) { std::string tmp = text; trimString(tmp); if(!isValidName(tmp, false)) msg << "That name to contain invalid symbols, please try again."; else { talkState[2] = false; talkState[3] = true; managerString = tmp; msg << "Do you really want to delete the character {" << managerString << "}? {yes} or {no}"; } } else if(checkText(text, "yes") && talkState[3]) { switch(IOLoginData::getInstance()->deleteCharacter(managerNumber, managerString)) { case DELETE_INTERNAL: msg << "An error occured while deleting your character. Either the character does not belong to you or it doesn't exist."; break; case DELETE_SUCCESS: msg << "Your character has been deleted."; break; case DELETE_HOUSE: msg << "Your character owns a house. You have to login and leave the house or pass it to someone else to complete."; break; case DELETE_LEADER: msg << "Your character is leader of a guild. You have to disband the guild or pass the leadership to someone else to complete."; break; case DELETE_ONLINE: msg << "Character with that name is currently online, to delete a character it has to be offline."; break; } talkState[1] = true; for(int8_t i = 2; i <= 12; ++i) talkState[i] = false; } else if(checkText(text, "no") && talkState[3]) { talkState[1] = true; talkState[3] = false; msg << "Which character would you like to delete then?"; } else if(checkText(text, "password") && talkState[1]) { talkState[1] = false; talkState[4] = true; msg << "What would you like your password to be?"; } else if(talkState[4]) { std::string tmp = text; trimString(tmp); if(tmp.length() < 6) msg << "That password is too short, please select a longer one."; else if(!isValidPassword(tmp)) msg << "Your password seems to contain invalid symbols, please choose another one."; else { talkState[4] = false; talkState[5] = true; managerString = tmp; msg << "{" << managerString << "} is it? {yes} or {no}?"; } } else if(checkText(text, "yes") && talkState[5]) { talkState[1] = true; for(int8_t i = 2; i <= 12; ++i) talkState[i] = false; IOLoginData::getInstance()->setPassword(managerNumber, managerString); msg << "Your password has been changed."; } else if(checkText(text, "no") && talkState[5]) { talkState[1] = true; for(int8_t i = 2; i <= 12; ++i) talkState[i] = false; msg << "Ok, then not."; } else if(checkText(text, "character") && talkState[1]) { if(account.charList.size() <= 15) { talkState[1] = false; talkState[6] = true; msg << "What would you like as your character name?"; } else { talkState[1] = true; for(int8_t i = 2; i <= 12; ++i) talkState[i] = false; msg << "Your account has reached the limit of 15 characters, you should {delete} a character if you want to create a new one."; } } else if(talkState[6]) { managerString = text; trimString(managerString); if(managerString.length() < 3) msg << "That name is too short, please select a longer one."; else if(managerString.length() > 30) msg << "That name is too long, please select a shorter one."; else if(!isValidName(managerString)) msg << "Your name seems to contain invalid symbols, please choose another one."; else if(IOLoginData::getInstance()->playerExists(managerString, true)) msg << "Player with that name already exists, please choose another one."; else { std::string tmp = asLowerCaseString(managerString); if(tmp.substr(0, 4) != "god " && tmp.substr(0, 3) != "cm " && tmp.substr(0, 3) != "gm ") { talkState[6] = false; talkState[7] = true; msg << "{" << managerString << "}, are you sure? {yes} or {no}"; } else msg << "Your character is not a staff member, please choose another name."; } } else if(checkText(text, "no") && talkState[7]) { talkState[6] = true; talkState[7] = false; msg << "What would you like your character name to be then?"; } else if(checkText(text, "yes") && talkState[7]) { talkState[7] = false; talkState[8] = true; msg << "Would you like to be a {male} or a {female}."; } else if(talkState[8] && (checkText(text, "female") || checkText(text, "male"))) { talkState[8] = false; talkState[9] = true; if(checkText(text, "female")) { msg << "A female, are you sure? {yes} or {no}"; managerSex = PLAYERSEX_FEMALE; } else { msg << "A male, are you sure? {yes} or {no}"; managerSex = PLAYERSEX_MALE; } } else if(checkText(text, "no") && talkState[9]) { talkState[8] = true; talkState[9] = false; msg << "Tell me then, would you like to be a {male} or a {female}?"; } else if(checkText(text, "yes") && talkState[9]) { if(g_config.getBool(ConfigManager::START_CHOOSEVOC)) { talkState[9] = false; talkState[11] = true; std::vector<std::string> vocations; for(VocationsMap::iterator it = Vocations::getInstance()->getFirstVocation(); it != Vocations::getInstance()->getLastVocation(); ++it) { if(it->first == it->second->getFromVocation() && it->first != 0) vocations.push_back(it->second->getName()); } msg << "What would you like to be... "; for(std::vector<std::string>::const_iterator it = vocations.begin(); it != vocations.end(); ++it) { if(it == vocations.begin()) msg << "{" << *it << "}"; else if(*it == *(vocations.rbegin())) msg << " or {" << *it << "}."; else msg << ", {" << *it << "}"; } } else if(!IOLoginData::getInstance()->playerExists(managerString, true)) { talkState[1] = true; for(int8_t i = 2; i <= 12; ++i) talkState[i] = false; if(IOLoginData::getInstance()->createCharacter(managerNumber, managerString, managerNumber2, (uint16_t)managerSex)) msg << "Your character {" << managerString << "} has been created."; else msg << "Your character couldn't be created, please contact with staff."; } else { talkState[6] = true; talkState[9] = false; msg << "Player with that name already exists, please choose another one."; } } else if(talkState[11]) { for(VocationsMap::iterator it = Vocations::getInstance()->getFirstVocation(); it != Vocations::getInstance()->getLastVocation(); ++it) { if(checkText(text, asLowerCaseString(it->second->getName())) && it->first == it->second->getFromVocation() && it->first != 0) { msg << "So you would like to be " << it->second->getDescription() << ", {yes} or {no}?"; managerNumber2 = it->first; talkState[11] = false; talkState[12] = true; } } } else if(checkText(text, "yes") && talkState[12]) { if(!IOLoginData::getInstance()->playerExists(managerString, true)) { talkState[1] = true; for(int8_t i = 2; i <= 12; ++i) talkState[i] = false; if(IOLoginData::getInstance()->createCharacter(managerNumber, managerString, managerNumber2, (uint16_t)managerSex)) msg << "Your character {" << managerString << "} has been created."; else msg << "Your character couldn't be created, please contact with staff."; } else { talkState[6] = true; talkState[9] = false; msg << "Player with that name already exists, please choose another one."; } } else if(checkText(text, "no") && talkState[12]) { talkState[11] = true; talkState[12] = false; msg << "What would you like to be then?"; } else if(checkText(text, "recovery key") && talkState[1]) { talkState[1] = false; talkState[10] = true; msg << "Would you like to generate a recovery key? {yes} or {no}"; } else if(checkText(text, "yes") && talkState[10]) { if(account.recoveryKey != "0") msg << "Sorry, but you already have a recovery key. For security reasons I may not generate for you you a new one."; else { managerString = generateRecoveryKey(4, 4); IOLoginData::getInstance()->setRecoveryKey(managerNumber, managerString); msg << "Your recovery key is {" << managerString << "}."; } talkState[1] = true; for(int8_t i = 2; i <= 12; ++i) talkState[i] = false; } else if(checkText(text, "no") && talkState[10]) { msg << "Ok, then not."; talkState[1] = true; for(int8_t i = 2; i <= 12; ++i) talkState[i] = false; } else msg << "Sorry, but I can't understand you, please try to repeat."; break; } case MANAGER_NEW: { if(checkText(text, "account") && !talkState[1]) { msg << "What would you like your password to be?"; talkState[1] = true; talkState[2] = true; } else if(talkState[2]) { std::string tmp = text; trimString(tmp); if(tmp.length() < 6) msg << "That password is too short, please select a longer one."; else if(!isValidPassword(tmp)) msg << "Your password seems to contain invalid symbols, please choose another one."; else { talkState[3] = true; talkState[2] = false; managerString = tmp; msg << "{" << managerString << "} is it? {yes} or {no}?"; } } else if(checkText(text, "yes") && talkState[3]) { if(g_config.getBool(ConfigManager::GENERATE_ACCOUNT_NUMBER)) { do sprintf(managerChar, "%d%d%d%d%d%d%d", random_range(2, 9), random_range(2, 9), random_range(2, 9), random_range(2, 9), random_range(2, 9), random_range(2, 9), random_range(2, 9)); while(IOLoginData::getInstance()->accountNameExists(managerChar)); uint32_t id = (uint32_t)IOLoginData::getInstance()->createAccount(managerChar, managerString); if(id) { accountManager = MANAGER_ACCOUNT; managerNumber = id; noSwap = talkState[1] = false; msg << "Your account has been created, you may manage it now, but please remember your account name {" << managerChar << "} and password {" << managerString << "}!"; } else msg << "Your account could not be created, please contact with staff."; for(int8_t i = 2; i <= 5; ++i) talkState[i] = false; } else { msg << "What would you like your account name to be?"; talkState[3] = false; talkState[4] = true; } } else if(checkText(text, "no") && talkState[3]) { talkState[2] = true; talkState[3] = false; msg << "What would you like your password to be then?"; } else if(talkState[4]) { std::string tmp = text; trimString(tmp); if(tmp.length() < 3) msg << "That account name is too short, please select a longer one."; else if(tmp.length() > 32) msg << "That account name is too long, please select a shorter one."; else if(!isValidAccountName(tmp)) msg << "Your account name seems to contain invalid symbols, please choose another one."; else if(asLowerCaseString(tmp) == asLowerCaseString(managerString)) msg << "Your account name cannot be same as password, please choose another one."; else { sprintf(managerChar, "%s", tmp.c_str()); msg << "{" << managerChar << "}, is it? {yes} or {no}?"; talkState[4] = false; talkState[5] = true; } } else if(checkText(text, "yes") && talkState[5]) { if(!IOLoginData::getInstance()->accountNameExists(managerChar)) { uint32_t id = (uint32_t)IOLoginData::getInstance()->createAccount(managerChar, managerString); if(id) { accountManager = MANAGER_ACCOUNT; managerNumber = id; noSwap = talkState[1] = false; msg << "Your account has been created, you may manage it now, but please remember your account name {" << managerChar << "} and password {" << managerString << "}!"; } else msg << "Your account could not be created, please contact with staff."; for(int8_t i = 2; i <= 5; ++i) talkState[i] = false; } else { msg << "Account with that name already exists, please choose another one."; talkState[4] = true; talkState[5] = false; } } else if(checkText(text, "no") && talkState[5]) { talkState[5] = false; talkState[4] = true; msg << "What would you like your account name to be then?"; } else if(checkText(text, "recover") && !talkState[6]) { talkState[6] = true; talkState[7] = true; msg << "What was your account name?"; } else if(talkState[7]) { managerString = text; if(IOLoginData::getInstance()->getAccountId(managerString, (uint32_t&)managerNumber)) { talkState[7] = false; talkState[8] = true; msg << "What was your recovery key?"; } else { msg << "Sorry, but account with name {" << managerString << "} does not exists."; talkState[6] = talkState[7] = false; } } else if(talkState[8]) { managerString2 = text; if(IOLoginData::getInstance()->validRecoveryKey(managerNumber, managerString2) && managerString2 != "0") { sprintf(managerChar, "%s%d", g_config.getString(ConfigManager::SERVER_NAME).c_str(), random_range(100, 999)); IOLoginData::getInstance()->setPassword(managerNumber, managerChar); msg << "Correct! Your new password is {" << managerChar << "}."; } else msg << "Sorry, but this key does not match to specified account."; talkState[7] = talkState[8] = false; } else msg << "Sorry, but I can't understand you, please try to repeat."; break; } default: return; break; } sendCreatureSay(this, MSG_NPC_FROM, msg.str()); if(!noSwap) sendCreatureSay(this, MSG_NPC_FROM, "Hint: Type {account} to manage your account and if you want to start over then type {cancel}."); } bool Player::isGuildInvited(uint32_t guildId) const { for(InvitationsList::const_iterator it = invitationsList.begin(); it != invitationsList.end(); ++it) { if((*it) == guildId) return true; } return false; } void Player::leaveGuild() { warMap.clear(); g_game.updateCreatureEmblem(this); sendClosePrivate(CHANNEL_GUILD); guildLevel = GUILDLEVEL_NONE; guildId = rankId = 0; guildName = rankName = guildNick = std::string(); } bool Player::isPremium() const { if(g_config.getBool(ConfigManager::FREE_PREMIUM) || hasFlag(PlayerFlag_IsAlwaysPremium)) return true; return (premiumDays != 0); } void Player::addPremiumDays(int32_t days) { if(premiumDays < GRATIS_PREMIUM) { Account account = IOLoginData::getInstance()->loadAccount(accountId); if(days < 0) { account.premiumDays = std::max((uint32_t)0, uint32_t(account.premiumDays + (int32_t)days)); premiumDays = std::max((uint32_t)0, uint32_t(premiumDays + (int32_t)days)); } else { account.premiumDays = std::min((uint32_t)65534, uint32_t(account.premiumDays + (uint32_t)days)); premiumDays = std::min((uint32_t)65534, uint32_t(premiumDays + (uint32_t)days)); } IOLoginData::getInstance()->saveAccount(account); sendBasicData(); } } bool Player::setGuildLevel(GuildLevel_t newLevel, uint32_t rank/* = 0*/) { std::string name; if(!IOGuild::getInstance()->getRankEx(rank, name, guildId, newLevel)) return false; guildLevel = newLevel; rankName = name; rankId = rank; return true; } void Player::setGroupId(int32_t newId) { if(Group* tmp = Groups::getInstance()->getGroup(newId)) { groupId = newId; group = tmp; } } void Player::setGroup(Group* newGroup) { if(!newGroup) return; group = newGroup; groupId = group->getId(); } PartyShields_t Player::getPartyShield(const Creature* creature) const { const Player* player = creature->getPlayer(); if(!player) return Creature::getPartyShield(creature); if(party) { if(party->getLeader() == player) { if(!party->isSharedExperienceActive()) return SHIELD_YELLOW; if(party->isSharedExperienceEnabled()) return SHIELD_YELLOW_SHAREDEXP; if(party->canUseSharedExperience(player)) return SHIELD_YELLOW_NOSHAREDEXP; return SHIELD_YELLOW_NOSHAREDEXP_BLINK; } if(party->isPlayerMember(player)) { if(!party->isSharedExperienceActive()) return SHIELD_BLUE; if(party->isSharedExperienceEnabled()) return SHIELD_BLUE_SHAREDEXP; if(party->canUseSharedExperience(player)) return SHIELD_BLUE_NOSHAREDEXP; return SHIELD_BLUE_NOSHAREDEXP_BLINK; } if(isInviting(player)) return SHIELD_WHITEBLUE; } if(player->isInviting(this)) return SHIELD_WHITEYELLOW; return SHIELD_NONE; } bool Player::isInviting(const Player* player) const { if(!player || player->isRemoved() || !party || party->getLeader() != this) return false; return party->isPlayerInvited(player); } bool Player::isPartner(const Player* player) const { return player && player->getParty() && player->getParty() == party; } bool Player::getHideHealth() const { if(hasFlag(PlayerFlag_HideHealth)) return true; return hideHealth; } void Player::sendPlayerIcons(Player* player) { sendCreatureShield(player); sendCreatureSkull(player); } bool Player::addPartyInvitation(Party* party) { if(!party) return false; PartyList::iterator it = std::find(invitePartyList.begin(), invitePartyList.end(), party); if(it != invitePartyList.end()) return false; invitePartyList.push_back(party); return true; } bool Player::removePartyInvitation(Party* party) { if(!party) return false; PartyList::iterator it = std::find(invitePartyList.begin(), invitePartyList.end(), party); if(it != invitePartyList.end()) { invitePartyList.erase(it); return true; } return false; } void Player::clearPartyInvitations() { if(invitePartyList.empty()) return; PartyList list; for(PartyList::iterator it = invitePartyList.begin(); it != invitePartyList.end(); ++it) list.push_back(*it); invitePartyList.clear(); for(PartyList::iterator it = list.begin(); it != list.end(); ++it) (*it)->removeInvite(this); } void Player::increaseCombatValues(int32_t& min, int32_t& max, bool useCharges, bool countWeapon) { if(min > 0) min = (int32_t)(min * vocation->getMultiplier(MULTIPLIER_HEALING)); else min = (int32_t)(min * vocation->getMultiplier(MULTIPLIER_MAGIC)); if(max > 0) max = (int32_t)(max * vocation->getMultiplier(MULTIPLIER_HEALING)); else max = (int32_t)(max * vocation->getMultiplier(MULTIPLIER_MAGIC)); Item* item = NULL; int32_t minValue = 0, maxValue = 0, i = SLOT_FIRST; for(; i < SLOT_LAST; ++i) { if(!(item = getInventoryItem((slots_t)i)) || item->isRemoved() || (g_moveEvents->hasEquipEvent(item) && !isItemAbilityEnabled((slots_t)i))) continue; const ItemType& it = Item::items[item->getID()]; if(!it.hasAbilities()) continue; if(min > 0) { minValue += it.abilities->increment[HEALING_VALUE]; if(it.abilities->increment[HEALING_PERCENT]) min = (int32_t)std::ceil((double)(min * it.abilities->increment[HEALING_PERCENT]) / 100.); } else { minValue -= it.abilities->increment[MAGIC_VALUE]; if(it.abilities->increment[MAGIC_PERCENT]) min = (int32_t)std::ceil((double)(min * it.abilities->increment[MAGIC_PERCENT]) / 100.); } if(max > 0) { maxValue += it.abilities->increment[HEALING_VALUE]; if(it.abilities->increment[HEALING_PERCENT]) max = (int32_t)std::ceil((double)(max * it.abilities->increment[HEALING_PERCENT]) / 100.); } else { maxValue -= it.abilities->increment[MAGIC_VALUE]; if(it.abilities->increment[MAGIC_PERCENT]) max = (int32_t)std::ceil((double)(max * it.abilities->increment[MAGIC_PERCENT]) / 100.); } bool removeCharges = false; for(int32_t j = INCREMENT_FIRST; j <= INCREMENT_LAST; ++j) { if(!it.abilities->increment[(Increment_t)j]) continue; removeCharges = true; break; } if(useCharges && removeCharges && (countWeapon || item != weapon) && item->hasCharges()) g_game.transformItem(item, item->getID(), std::max((int32_t)0, (int32_t)item->getCharges() - 1)); } min += minValue; max += maxValue; } bool Player::transferMoneyTo(const std::string& name, uint64_t amount) { if(!g_config.getBool(ConfigManager::BANK_SYSTEM) || amount > balance) return false; Player* target = g_game.getPlayerByNameEx(name); if(!target) return false; balance -= amount; target->balance += amount; if(target->isVirtual()) { IOLoginData::getInstance()->savePlayer(target); delete target; } return true; } void Player::sendCritical() const { //if(g_config.getBool(ConfigManager::DISPLAY_CRITICAL_HIT)) //sendTextMessage(MSG_STATUS_CONSOLE_RED, "You strike a critical hit!"); if(g_config.getBool(ConfigManager::DISPLAY_CRITICAL_HIT)) sendTextMessage(MSG_STATUS_CONSOLE_ORANGE, "Critical Hit!"); } void Player::setMounted(bool mounting) { if(!mounting) { dismount(true); return; } if(_tile->hasFlag(TILESTATE_PROTECTIONZONE) && g_config.getBool(ConfigManager::UNMOUNT_PLAYER_IN_PZ) && !hasFlag(PlayerFlag_IgnoreProtectionZone)) sendCancelMessage(RET_ACTIONNOTPERMITTEDINPROTECTIONZONE); else if(Mounts::getInstance()->isPremium() && !isPremium()) sendCancelMessage(RET_YOUNEEDPREMIUMACCOUNT); else if(!defaultOutfit.lookMount) sendOutfitWindow(); else if(!mounted) { if(Mount* mount = Mounts::getInstance()->getMountByCid(defaultOutfit.lookMount)) { bool deny = false; CreatureEventList mountEvents = this->getCreatureEvents(CREATURE_EVENT_MOUNT); for(CreatureEventList::iterator it = mountEvents.begin(); it != mountEvents.end(); ++it) { if(!(*it)->executeMount(this, mount->getId()) && !deny) deny = true; } if(deny) return; mounted = true; if(mount->getSpeed()) g_game.changeSpeed(this, mount->getSpeed()); mount->addAttributes(this); g_game.internalCreatureChangeOutfit(this, defaultOutfit, true); } } } void Player::dismount(bool update) { if(!mounted) return; if(!defaultOutfit.lookMount) return; if(Mount* mount = Mounts::getInstance()->getMountByCid(defaultOutfit.lookMount)) { bool deny = false; CreatureEventList dismountEvents = this->getCreatureEvents(CREATURE_EVENT_DISMOUNT); for(CreatureEventList::iterator it = dismountEvents.begin(); it != dismountEvents.end(); ++it) { if(!(*it)->executeDismount(this, mount->getId()) && !deny) deny = true; } if(deny) return; mounted = false; if(mount->getSpeed() > 0) g_game.changeSpeed(this, -(int32_t)mount->getSpeed()); mount->removeAttributes(this); } if(update) g_game.internalCreatureChangeOutfit(this, defaultOutfit, true); } bool Player::tameMount(uint8_t mountId) { if(!Mounts::getInstance()->getMountById(mountId)) return false; --mountId; int32_t key = PSTRG_MOUNTS_RANGE_START + (mountId / 31), value = 0; std::string tmp; if(getStorage(asString(key), tmp)) { value = atoi(tmp.c_str()); value |= (int32_t)pow(2., mountId % 31); } else value = (int32_t)pow(2., mountId % 31); setStorage(asString(key), asString(value)); return true; } bool Player::untameMount(uint8_t mountId) { if(!Mounts::getInstance()->getMountById(mountId)) return false; --mountId; int32_t key = PSTRG_MOUNTS_RANGE_START + (mountId / 31), value = 0; std::string tmp; if(!getStorage(asString(key), tmp)) return true; value = atoi(tmp.c_str()); value &= ~((int32_t)std::pow(2., mountId % 31)); Mount* mount = Mounts::getInstance()->getMountByCid(defaultOutfit.lookMount); if(mount && mount->getId() == (mountId + 1)) { dismount(true); defaultOutfit.lookMount = 0; } setStorage(asString(key), asString(value)); return true; } bool Player::addOfflineTrainingTries(skills_t skill, int32_t tries) { if(tries <= 0 || skill == SKILL__LEVEL || skill == SKILL__EXPERIENCE) return false; uint32_t oldSkillValue, newSkillValue; long double oldPercentToNextLevel, newPercentToNextLevel; std::ostringstream ss; if(skill == SKILL__MAGLEVEL) { uint64_t currReqMana = vocation->getReqMana(magLevel), nextReqMana = vocation->getReqMana(magLevel + 1); if(currReqMana >= nextReqMana) return false; oldSkillValue = magLevel; oldPercentToNextLevel = (long double)(manaSpent * 100) / nextReqMana; tries *= g_config.getDouble(ConfigManager::RATE_MAGIC_OFFLINE); while((manaSpent + tries) >= nextReqMana) { tries -= nextReqMana - manaSpent; manaSpent = 0; magLevel++; CreatureEventList advanceEvents = getCreatureEvents(CREATURE_EVENT_ADVANCE); for(CreatureEventList::iterator it = advanceEvents.begin(); it != advanceEvents.end(); ++it) (*it)->executeAdvance(this, SKILL__MAGLEVEL, (magLevel - 1), magLevel); currReqMana = nextReqMana; nextReqMana = vocation->getReqMana(magLevel + 1); if(currReqMana >= nextReqMana) { tries = 0; break; } } if(tries) manaSpent += tries; uint32_t newPercent; if(nextReqMana > currReqMana) { newPercent = Player::getPercentLevel(manaSpent, nextReqMana); newPercentToNextLevel = (long double)(manaSpent * 100) / nextReqMana; } else newPercent = newPercentToNextLevel = 0; if(newPercent != magLevelPercent) { magLevelPercent = newPercent; sendStats(); } newSkillValue = magLevel; ss << "You advanced to magic level " << magLevel << "."; sendTextMessage(MSG_EVENT_ADVANCE, ss.str().c_str()); ss.str(""); } else { uint64_t currReqTries = vocation->getReqSkillTries(skill, skills[skill][SKILL_LEVEL]), nextReqTries = vocation->getReqSkillTries(skill, skills[skill][SKILL_LEVEL] + 1); if(currReqTries >= nextReqTries) return false; oldSkillValue = skills[skill][SKILL_LEVEL]; oldPercentToNextLevel = (long double)(skills[skill][SKILL_TRIES] * 100) / nextReqTries; tries *= g_config.getDouble(ConfigManager::RATE_SKILL_OFFLINE); while((skills[skill][SKILL_TRIES] + tries) >= nextReqTries) { tries -= nextReqTries - skills[skill][SKILL_TRIES]; skills[skill][SKILL_LEVEL]++; skills[skill][SKILL_TRIES] = skills[skill][SKILL_PERCENT] = 0; CreatureEventList advanceEvents = getCreatureEvents(CREATURE_EVENT_ADVANCE); for(CreatureEventList::iterator it = advanceEvents.begin(); it != advanceEvents.end(); ++it) (*it)->executeAdvance(this, skill, (skills[skill][SKILL_LEVEL] - 1), skills[skill][SKILL_LEVEL]); currReqTries = nextReqTries; nextReqTries = vocation->getReqSkillTries(skill, skills[skill][SKILL_LEVEL] + 1); if(currReqTries >= nextReqTries) { tries = 0; break; } } if(tries) skills[skill][SKILL_TRIES] += tries; uint32_t newPercent; if(nextReqTries > currReqTries) { newPercent = Player::getPercentLevel(skills[skill][SKILL_TRIES], nextReqTries); newPercentToNextLevel = (long double)(skills[skill][SKILL_TRIES] * 100) / nextReqTries; } else newPercent = newPercentToNextLevel = 0; if(skills[skill][SKILL_PERCENT] != newPercent) { skills[skill][SKILL_PERCENT] = newPercent; sendStats(); } newSkillValue = skills[skill][SKILL_LEVEL]; ss << "You advanced to " << getSkillName(skill) << " level " << skills[skill][SKILL_LEVEL] << "."; sendTextMessage(MSG_EVENT_ADVANCE, ss.str().c_str()); ss.str(""); } ss << std::fixed << std::setprecision(2) << "Your " << ucwords(getSkillName(skill)) << " skill changed from level " << oldSkillValue << " (with " << oldPercentToNextLevel << "% progress towards level " << (oldSkillValue + 1) << ") to level " << newSkillValue << " (with " << newPercentToNextLevel << "% progress towards level " << (newSkillValue + 1) << ")"; sendTextMessage(MSG_EVENT_ADVANCE, ss.str().c_str()); return true; } void Player::executeSleep(uint8_t button, uint8_t choice) { if(!bed) return; if(button != 1 || !bed->canUse(this) || (choice > SKILL_DIST && choice != SKILL__MAGLEVEL)) { bed = NULL; return; } offlineTrainingSkill = choice; bed->sleep(this); bed = NULL; } void Player::prepareSleep(BedItem* _bed) { ModalDialog tmp; ModalChoice tmpChoice; tmp.id = OFFLINE_TRAINING_DIALOG; tmp.title = "Choose a skill"; tmp.message = "Please choose a skill:"; tmp.popup = true; tmpChoice.id = tmp.buttonEnter = 1; tmpChoice.value = "Okay"; tmp.buttons.push_back(tmpChoice); tmpChoice.id = tmp.buttonEscape = 2; tmpChoice.value = "Cancel"; tmp.buttons.push_back(tmpChoice); tmpChoice.id = SKILL_SWORD; tmpChoice.value = ucwords(getSkillName(SKILL_SWORD)); tmp.choices.push_back(tmpChoice); tmpChoice.id = SKILL_AXE; tmpChoice.value = ucwords(getSkillName(SKILL_AXE)); tmp.choices.push_back(tmpChoice); tmpChoice.id = SKILL_CLUB; tmpChoice.value = ucwords(getSkillName(SKILL_CLUB)); tmp.choices.push_back(tmpChoice); tmpChoice.id = SKILL_DIST; tmpChoice.value = ucwords(getSkillName(SKILL_DIST)); tmp.choices.push_back(tmpChoice); tmpChoice.id = SKILL__MAGLEVEL; tmpChoice.value = ucwords(getSkillName(SKILL__MAGLEVEL)); tmp.choices.push_back(tmpChoice); tmpChoice.id = SKILL_FIST; tmpChoice.value = ucwords(getSkillName(SKILL_FIST)); tmp.choices.push_back(tmpChoice); dialogControl.dialogId = OFFLINE_TRAINING_DIALOG; dialogControl.pos = getPosition(); bed = _bed; sendModalDialog(tmp); }
  8. tem que alterar isso em player.cpp uint32_t Player::getAttackSpeed() const { int32_t modifiers = 0; if(mounted) { if(Mount* tmp = Mounts::getInstance()->getMountByCid(defaultOutfit.lookMount)) { if(tmp->getAttackSpeed() == -1) return 0; modifiers += tmp->getAttackSpeed(); } } if(outfitAttributes) { Outfit outfit; if(Outfits::getInstance()->getOutfit(defaultOutfit.lookType, outfit)) { if(outfit.attackSpeed == -1) return 0; modifiers += outfit.attackSpeed; } } Item* _weapon = weapon; if(!weapon || weapon->getWeaponType() == WEAPON_AMMO) _weapon = const_cast<Player*>(this)->getWeapon(true); //--- return (((_weapon && _weapon->getAttackSpeed() != 0) ? _weapon->getAttackSpeed() : (vocation->getAttackSpeed() / std::max((size_t)1, getWeapons().size()))) + modifiers); return (((weapon && weapon->getAttackSpeed() != 0) ? weapon->getAttackSpeed() * (1 - (getSkill(SKILL_FIST, SKILL_LEVEL) * 0.00475)) : (vocation->getAttackSpeed() / std::max((size_t)1, getWeapons().size()) * (1 - (getSkill(SKILL_FIST, SKILL_LEVEL) * 0.00475)))) + modifiers); //-- Mudei aqui }
  9. TFS 0.3.7 Eu fiz assim no meu e funcionou.. uint32_t Player::getAttackSpeed() const { int32_t modifiers = 0; if(mounted) { if(Mount* tmp = Mounts::getInstance()->getMountByCid(defaultOutfit.lookMount)) { if(tmp->getAttackSpeed() == -1) return 0; modifiers += tmp->getAttackSpeed(); } } if(outfitAttributes) { Outfit outfit; if(Outfits::getInstance()->getOutfit(defaultOutfit.lookType, outfit)) { if(outfit.attackSpeed == -1) return 0; modifiers += outfit.attackSpeed; } } Item* _weapon = weapon; if(!weapon || weapon->getWeaponType() == WEAPON_AMMO) _weapon = const_cast<Player*>(this)->getWeapon(true); //--- return (((_weapon && _weapon->getAttackSpeed() != 0) ? _weapon->getAttackSpeed() : (vocation->getAttackSpeed() / std::max((size_t)1, getWeapons().size()))) + modifiers); return (((weapon && weapon->getAttackSpeed() != 0) ? weapon->getAttackSpeed() * (1 - (getSkill(SKILL_FIST, SKILL_LEVEL) * 0.00375)) : (vocation->getAttackSpeed() / std::max((size_t)1, getWeapons().size()) * (1 - (getSkill(SKILL_FIST, SKILL_LEVEL) * 0.00375)))) + modifiers); //-- Mudei aqui }
  10. @xWhiteWolf como faço para acionar -- absorbPercentPhysical -- nos atributos do item, e para poder usar somente em shields.. attributes = { ["attack"] = 2, ["defense"] = 1, ["armor"] = 1 },, absorbPercentPhysical
  11. Bom dia consegue colocar pra ele verificar o IP do player também?
  12. robiie123

    Sprites Zezenia

    Obrigado Otavio pelas palavras.

Open Tibia Server

Quer aprender a criar seu próprio servidor de Tibia? Então está no lugar certo, aqui você encontrará milhares de tutorias, scripts, códigos, mapas e utilitários para que você possa fazer o seu próprio servidor de Tibia partindo do zero.

Redes Sociais

Anuncie no Tibia King

Precisa de mais visibilidade em seus projetos? Quer publicidade para o seu servidor? Anuncie no Tibia King e faça sua divulgação, possuímos centenas de acessos simultâneos e milhares diários, com certeza será a sua solução! A publicação do seu anuncio é instantânea!

×