bool IOGuild::canLeaveWar(uint32_t guildId)
{
if(!isInWar(guildId))
return true;
Database* db = Database::getInstance();
DBQuery query;
DBResult* result;
bool returnVal = true;
query << "SELECT `started` FROM `guild_wars` WHERE `guild1` = " << guildId << " AND `ended` = 0 AND `status` = 1;";
if((result = db->storeQuery(query.str())))
{
do {
if((result->getDataLong("started") + (86400 * 4)) >= time(NULL))
returnVal = false;
} while (result->next());
db->freeResult(result);
}
query.str("");
query << "SELECT `started` FROM `guild_wars` WHERE `guild2` = " << guildId << " AND `ended` = 0 AND `status` = 1;";
if((result = db->storeQuery(query.str())))
{
do {
if((result->getDataLong("started") + (86400 * 4)) >= time(NULL))
returnVal = false;
} while (result->next());
db->freeResult(result);
}
return returnVal;
}
std::vector<Ban> BanManager::getBans(const BanType_t& type)
{
assert(type == BAN_IPADDRESS || type == BAN_PLAYER || type == BAN_ACCOUNT || type == BAN_NOTATION);
Database* db = Database::instance();
DBQuery query;
query <<
"SELECT "
"`id`, "
"`value`, "
"`param`, "
"`expires`, "
"`added`, "
"`admin_id`, "
"`comment`, "
"`reason`, "
"`action`, "
"`statement` "
"FROM "
"`bans` "
"WHERE "
"`type` = " << type << " AND "
"`active` = 1 AND " <<
"(`expires` >= " << std::time(NULL) << " OR `expires` = 0)";
std::vector<Ban> vec;
DBResult* result;
if (!(result = db->storeQuery(query.str())))
{
return vec;
}
do
{
Ban ban;
ban.type = type;
ban.id = result->getDataInt("id");
ban.value = result->getDataString("value");
ban.param = result->getDataString("param");
ban.expires = result->getDataLong("expires");
ban.added = (uint32_t)result->getDataLong("id");
ban.adminId = result->getDataInt("admin_id");
ban.reason = result->getDataInt("reason");
ban.action = (violationAction_t)result->getDataInt("action");
ban.comment = result->getDataString("comment");
ban.statement = result->getDataString("statement");
vec.push_back(ban);
}
while (result->next());
db->freeResult(result);
return vec;
}
const PlayerGroup* IOPlayer::getPlayerGroup(uint32_t groupid)
{
PlayerGroupMap::const_iterator it = playerGroupMap.find(groupid);
if(it != playerGroupMap.end()){
return it->second;
}
else{
Database* db = Database::instance();
DBQuery query;
DBResult* result;
query << "SELECT * FROM `groups` WHERE `id`= " << groupid;
if((result = db->storeQuery(query.str()))){
PlayerGroup* group = new PlayerGroup;
group->m_name = result->getDataString("name");
group->m_flags = result->getDataLong("flags");
group->m_access = result->getDataInt("access");
group->m_maxDepotItems = result->getDataInt("maxdepotitems");
group->m_maxVip = result->getDataInt("maxviplist");
playerGroupMap[groupid] = group;
db->freeResult(result);
return group;
}
}
return NULL;
}
const PlayerGroup* IOLoginData::getPlayerGroup(uint32_t groupid)
{
PlayerGroupMap::const_iterator it = playerGroupMap.find(groupid);
if (it != playerGroupMap.end()) {
return it->second;
}
Database* db = Database::getInstance();
std::ostringstream query;
query << "SELECT `name`, `flags`, `access`, `maxdepotitems`, `maxviplist` FROM `groups` WHERE `id` = " << groupid;
DBResult* result = db->storeQuery(query.str());
if (!result) {
return NULL;
}
PlayerGroup* group = new PlayerGroup;
group->m_name = result->getDataString("name");
group->m_flags = result->getDataLong("flags");
group->m_access = result->getDataInt("access");
group->m_maxdepotitems = result->getDataInt("maxdepotitems");
group->m_maxviplist = result->getDataInt("maxviplist");
db->freeResult(result);
playerGroupMap[groupid] = group;
return group;
}
void IOMarket::updateStatistics()
{
Database* db = Database::getInstance();
DBQuery query;
query << "SELECT `sale`, `itemtype`, COUNT(`price`) AS `num`, MIN(`price`) AS `min`, MAX(`price`) AS `max`, SUM(`price`) AS `sum` FROM `market_history` WHERE `state` = "
<< OFFERSTATE_ACCEPTED << " AND `world_id` = " << g_config.getNumber(ConfigManager::WORLD_ID) << " GROUP BY `itemtype`, `sale`;";
DBResult* result;
if(!(result = db->storeQuery(query.str())))
return;
do
{
MarketStatistics* statistics;
if(result->getDataInt("sale") == MARKETACTION_BUY)
statistics = &purchaseStatistics[result->getDataInt("itemtype")];
else
statistics = &saleStatistics[result->getDataInt("itemtype")];
statistics->numTransactions = result->getDataInt("num");
statistics->lowestPrice = result->getDataInt("min");
statistics->totalPrice = result->getDataLong("sum");
statistics->highestPrice = result->getDataInt("max");
}
while(result->next());
result->free();
}
DatabaseMySQL::DatabaseMySQL() :
m_timeoutTask(0)
{
m_connected = false;
if(!mysql_init(&m_handle))
{
std::clog << std::endl << "Failed to initialize MySQL connection handler." << std::endl;
return;
}
uint32_t timeout = g_config.getNumber(ConfigManager::MYSQL_READ_TIMEOUT);
if(timeout)
mysql_options(&m_handle, MYSQL_OPT_READ_TIMEOUT, (const char*)&timeout);
timeout = g_config.getNumber(ConfigManager::MYSQL_WRITE_TIMEOUT);
if(timeout)
mysql_options(&m_handle, MYSQL_OPT_WRITE_TIMEOUT, (const char*)&timeout);
my_bool reconnect = true;
mysql_options(&m_handle, MYSQL_OPT_RECONNECT, &reconnect);
if(!mysql_real_connect(&m_handle, g_config.getString(ConfigManager::SQL_HOST).c_str(), g_config.getString(
ConfigManager::SQL_USER).c_str(), g_config.getString(ConfigManager::SQL_PASS).c_str(), g_config.getString(
ConfigManager::SQL_DB).c_str(), g_config.getNumber(ConfigManager::SQL_PORT), NULL, 0))
{
std::clog << "Failed connecting to database - MYSQL ERROR: " << mysql_error(&m_handle) << " (" << mysql_errno(&m_handle) << ")" << std::endl;
return;
}
m_connected = true;
if(mysql_get_client_version() <= 50019)
//MySQL servers <= 5.0.19 have a bug where MYSQL_OPT_RECONNECT option is reset by mysql_real_connect calls.
//Read this http://dev.mysql.com/doc/refman/5.0/en/mysql-options.html for more information.
std::clog << std::endl << "> WARNING: Outdated MySQL server detected, consider upgrading to a newer version." << std::endl;
timeout = g_config.getNumber(ConfigManager::SQL_KEEPALIVE) * 1000;
if(timeout)
m_timeoutTask = Scheduler::getInstance().addEvent(createSchedulerTask(timeout,
boost::bind(&DatabaseMySQL::keepAlive, this)));
if(!g_config.getBool(ConfigManager::HOUSE_STORAGE))
return;
//we cannot lock mutex here :)
DBResult* result = storeQuery("SHOW variables LIKE 'max_allowed_packet';");
if(!result)
return;
if(result->getDataLong("Value") < 16776192)
std::clog << std::endl << "> WARNING: max_allowed_packet might be set too low for binary map storage." << std::endl
<< "Use the following query to raise max_allow_packet: SET GLOBAL max_allowed_packet = 16776192;" << std::endl;
result->free();
}
bool IOPlayer::internalHasFlag(uint32_t groupId, PlayerFlags value)
{
PlayerGroupMap::const_iterator it = playerGroupMap.find(groupId);
if(it != playerGroupMap.end())
return (0 != (it->second->m_flags & ((uint64_t)1 << value)));
Database* db = Database::instance();
DBResult* result;
DBQuery query;
query << "SELECT `flags` FROM `groups` WHERE `id` = " << groupId;
if(!(result = db->storeQuery(query.str())))
return false;
uint64_t flags = result->getDataLong("flags");
db->freeResult(result);
return (0 != (flags & ((uint64_t)1 << value)));
}
time_t IOLoginData::getLastLoginSaved(uint32_t guid)
{
Database* db = Database::getInstance();
std::ostringstream query;
query << "SELECT `lastlogin` FROM `players` WHERE `id` = " << guid;
DBResult* result;
time_t lastLoginSaved;
if ((result = db->storeQuery(query.str()))) {
lastLoginSaved = result->getDataLong("lastlogin");
db->freeResult(result);
} else {
lastLoginSaved = 0;
}
return lastLoginSaved;
}
bool IOPlayer::loadPlayer(Player* player, const std::string& name, bool preload /*= false*/)
{
Database* db = Database::instance();
DBQuery query;
DBResult* result;
query << "SELECT `players`.`id` AS `id`, `players`.`name` AS `name`, `account_id`, \
`players`.`group_id` as `group_id`, `sex`, `vocation`, `experience`, `level`, `maglevel`, `health`, \
`healthmax`, `mana`, `manamax`, `manaspent`, `soul`, `direction`, `lookbody`, \
`lookfeet`, `lookhead`, `looklegs`, `looktype`, `posx`, `posy`, \
`posz`, `cap`, `lastlogin`, `lastip`, `save`, `conditions`, `redskulltime`, \
`redskull`, `guildnick`, `loss_experience`, `loss_mana`, `loss_skills`, \
`loss_items`, `rank_id`, `town_id`, `balance`, `premend` \
FROM `players` LEFT JOIN `accounts` ON `account_id` = `accounts`.`id` \
WHERE `players`.`name` = " + db->escapeString(name);
if(!(result = db->storeQuery(query.str()))){
return false;
}
query.str("");
player->setGUID(result->getDataInt("id"));
player->accountNumber = result->getDataInt("account_id");
const PlayerGroup* group = getPlayerGroup(result->getDataInt("group_id"));
if(group){
player->accessLevel = group->m_access;
player->maxDepotLimit = group->m_maxDepotItems;
player->maxVipLimit = group->m_maxVip;
player->setFlags(group->m_flags);
}
if(preload){
//only loading basic info
db->freeResult(result);
return true;
}
// Getting all player properties
player->setSex((playersex_t)result->getDataInt("sex"));
player->setDirection((Direction)result->getDataInt("direction"));
player->level = std::max((uint32_t)1, (uint32_t)result->getDataInt("level"));
uint64_t currExpCount = Player::getExpForLevel(player->level);
uint64_t nextExpCount = Player::getExpForLevel(player->level + 1);
uint64_t experience = (uint64_t)result->getDataLong("experience");
if(experience < currExpCount || experience > nextExpCount){
experience = currExpCount;
}
player->experience = experience;
player->levelPercent = Player::getPercentLevel(player->experience - currExpCount, nextExpCount - currExpCount);
player->soul = result->getDataInt("soul");
player->capacity = result->getDataInt("cap");
player->lastLoginSaved = result->getDataInt("lastlogin");
player->health = result->getDataInt("health");
player->healthMax = result->getDataInt("healthmax");
player->defaultOutfit.lookType = result->getDataInt("looktype");
player->defaultOutfit.lookHead = result->getDataInt("lookhead");
player->defaultOutfit.lookBody = result->getDataInt("lookbody");
player->defaultOutfit.lookLegs = result->getDataInt("looklegs");
player->defaultOutfit.lookFeet = result->getDataInt("lookfeet");
player->currentOutfit = player->defaultOutfit;
#ifdef __SKULLSYSTEM__
int32_t redSkullSeconds = result->getDataInt("redskulltime") - std::time(NULL);
if(redSkullSeconds > 0){
//ensure that we round up the number of ticks
player->redSkullTicks = (redSkullSeconds + 2)*1000;
if(result->getDataInt("redskull") == 1){
player->skull = SKULL_RED;
}
}
#endif
unsigned long conditionsSize = 0;
const char* conditions = result->getDataStream("conditions", conditionsSize);
PropStream propStream;
propStream.init(conditions, conditionsSize);
Condition* condition;
while((condition = Condition::createCondition(propStream))){
if(condition->unserialize(propStream)){
player->storedConditionList.push_back(condition);
}
else{
delete condition;
}
}
// you need to set the vocation after conditions in order to ensure the proper regeneration rates for the vocation
player->setVocation(result->getDataInt("vocation"));
// this stuff has to go after the vocation is set
player->mana = result->getDataInt("mana");
player->manaMax = result->getDataInt("manamax");
player->magLevel = result->getDataInt("maglevel");
uint32_t nextManaCount = (uint32_t)player->vocation->getReqMana(player->magLevel + 1);
uint32_t manaSpent = (uint32_t)result->getDataInt("manaspent");
if(manaSpent > nextManaCount){
//make sure its not out of bound
manaSpent = 0;
}
player->manaSpent = manaSpent;
player->magLevelPercent = Player::getPercentLevel(player->manaSpent, nextManaCount);
player->setLossPercent(LOSS_EXPERIENCE, result->getDataInt("loss_experience"));
player->setLossPercent(LOSS_MANASPENT, result->getDataInt("loss_mana"));
player->setLossPercent(LOSS_SKILLTRIES, result->getDataInt("loss_skills"));
player->setLossPercent(LOSS_ITEMS, result->getDataInt("loss_items"));
player->loginPosition.x = result->getDataInt("posx");
player->loginPosition.y = result->getDataInt("posy");
player->loginPosition.z = result->getDataInt("posz");
player->town = result->getDataInt("town_id");
Town* town = Towns::getInstance().getTown(player->town);
if(town){
player->masterPos = town->getTemplePosition();
}
//if posx == 0 AND posy == 0 AND posz == 0
// login position is temple position
Position loginPos = player->loginPosition;
if (loginPos.x == 0 && loginPos.y == 0 && loginPos.z == 0) {
player->loginPosition = player->masterPos;
}
Account acc;
if (player->getVocationId() && acc.premEnd > 0 && acc.premEnd < std::time(NULL) && (g_config.getNumber(ConfigManager::TEMPLE_TP_ID) != 0)){
town = Towns::getInstance().getTown(g_config.getNumber(ConfigManager::TEMPLE_TP_ID));
player->loginPosition = town->getTemplePosition();
}
uint32_t rankid = result->getDataInt("rank_id");
// place it here and now we can drop all additional query instances as all data were loaded
player->premiumEnd = result->getDataInt("premend");
player->balance = result->getDataInt("balance");
player->guildNick = result->getDataString("guildnick");
db->freeResult(result);
if(rankid){
query << "SELECT `guild_ranks`.`name` as `rank`, `guild_ranks`.`guild_id` as `guildid`, `guild_ranks`.`level` as `level`, `guilds`.`name` as `guildname` FROM `guild_ranks`, `guilds` WHERE `guild_ranks`.`id` = " << rankid << " AND `guild_ranks`.`guild_id` = `guilds`.`id`";
if((result = db->storeQuery(query.str()))){
player->guildName = result->getDataString("guildname");
player->guildLevel = result->getDataInt("level");
player->guildId = result->getDataInt("guildid");
player->guildRank = result->getDataString("rank");
db->freeResult(result);
}
query.str("");
}
//get password
query << "SELECT `password` FROM `accounts` WHERE `id` = " << player->accountNumber;
if(!(result = db->storeQuery(query.str()))){
return false;
}
player->password = result->getDataString("password");
db->freeResult(result);
// we need to find out our skills
// so we query the skill table
query.str("");
query << "SELECT `skillid`, `value`, `count` FROM `player_skills` WHERE `player_id` = " << player->getGUID();
if((result = db->storeQuery(query.str()))){
//now iterate over the skills
do{
int skillid = result->getDataInt("skillid");
if(skillid >= SKILL_FIRST && skillid <= SKILL_LAST){
uint32_t skillLevel = result->getDataInt("value");
uint32_t skillCount = result->getDataInt("count");
uint32_t nextSkillCount = player->vocation->getReqSkillTries(skillid, skillLevel + 1);
if(skillCount > nextSkillCount){
//make sure its not out of bound
skillCount = 0;
}
player->skills[skillid][SKILL_LEVEL] = skillLevel;
player->skills[skillid][SKILL_TRIES] = skillCount;
player->skills[skillid][SKILL_PERCENT] = Player::getPercentLevel(skillCount, nextSkillCount);
}
}while(result->next());
db->freeResult(result);
}
query.str("");
query << "SELECT `name` FROM `player_spells` WHERE `player_id` = " << player->getGUID();
if((result = db->storeQuery(query.str()))){
do{
std::string spellName = result->getDataString("name");
player->learnedInstantSpellList.push_back(spellName);
}while(result->next());
db->freeResult(result);
}
//load inventory items
ItemMap itemMap;
query.str("");
query << "SELECT `pid`, `sid`, `itemtype`, `count`, `attributes` FROM `player_items` WHERE `player_id` = " << player->getGUID() << " ORDER BY `sid` DESC";
if((result = db->storeQuery(query.str()))){
loadItems(itemMap, result);
ItemMap::reverse_iterator it;
ItemMap::iterator it2;
for(it = itemMap.rbegin(); it != itemMap.rend(); ++it){
Item* item = it->second.first;
int pid = it->second.second;
if(pid >= 1 && pid <= 10){
player->__internalAddThing(pid, item);
}
else{
it2 = itemMap.find(pid);
if(it2 != itemMap.end())
if(Container* container = it2->second.first->getContainer()){
container->__internalAddThing(item);
}
}
}
db->freeResult(result);
}
//load depot items
itemMap.clear();
query.str("");
query << "SELECT `pid`, `sid`, `itemtype`, `count`, `attributes` FROM `player_depotitems` WHERE `player_id` = " << player->getGUID() << " ORDER BY `sid` DESC";
if((result = db->storeQuery(query.str()))){
loadItems(itemMap, result);
ItemMap::reverse_iterator it;
ItemMap::iterator it2;
for(it = itemMap.rbegin(); it != itemMap.rend(); ++it){
Item* item = it->second.first;
int pid = it->second.second;
if(pid >= 0 && pid < 100){
if(Container* c = item->getContainer()){
if(Depot* depot = c->getDepot())
player->addDepot(depot, pid);
else
std::cout << "Error loading depot "<< pid << " for player " << player->getGUID() << std::endl;
}
else{
std::cout << "Error loading depot "<< pid << " for player " <<
player->getGUID() << std::endl;
}
}
else{
it2 = itemMap.find(pid);
if(it2 != itemMap.end())
if(Container* container = it2->second.first->getContainer()){
container->__internalAddThing(item);
}
}
}
db->freeResult(result);
}
//load storage map
query.str("");
query << "SELECT `key`, `value` FROM `player_storage` WHERE `player_id` = " << player->getGUID();
if((result = db->storeQuery(query.str()))){
do{
uint32_t key = result->getDataInt("key");
int32_t value = result->getDataInt("value");
player->addStorageValue(key,value);
}while(result->next());
db->freeResult(result);
}
//load vip
query.str("");
query << "SELECT `vip_id` FROM `player_viplist` WHERE `player_id` = " << player->getGUID();
if((result = db->storeQuery(query.str()))){
do{
uint32_t vip_id = result->getDataInt("vip_id");
std::string dummy_str;
if(storeNameByGuid(*db, vip_id))
player->addVIP(vip_id, dummy_str, false, true);
}while(result->next());
db->freeResult(result);
}
player->updateBaseSpeed();
player->updateInventoryWeigth();
player->updateItemsLight(true);
return true;
}
bool IOPlayer::loadPlayer(Player* player, const std::string& name, bool preload /*= false*/)
{
Database* db = Database::instance();
DBQuery query;
DBResult* result;
query << "SELECT `players`.`id` AS `id`, `players`.`name` AS `name`, \
`account_id`, `sex`, `vocation`, `experience`, `level`, `maglevel`, `health`, \
`groups`.`name` AS `groupname`, `groups`.`flags` AS `groupflags`, `groups`.`access` AS `access`, \
`groups`.`maxviplist` AS `maxviplist`, `groups`.`maxdepotitems` AS `maxdepotitems`, `groups`.`violation` AS `violation`, \
`healthmax`, `mana`, `manamax`, `manaspent`, `soul`, `direction`, `lookbody`, \
`lookfeet`, `lookhead`, `looklegs`, `looktype`, `posx`, `posy`, \
`posz`, `cap`, `lastlogin`, `lastlogout`, `lastip`, `conditions`, `skull_time`, \
`skull_type`, `loss_experience`, `loss_mana`, `loss_skills`, ";
#ifdef __OLD_GUILD_SYSTEM__
query << "`rank_id`, `guildnick`, ";
#endif
query << "`loss_items`, `loss_containers`, `town_id`, `balance` \
FROM `players` \
LEFT JOIN `accounts` ON `account_id` = `accounts`.`id`\
LEFT JOIN `groups` ON `groups`.`id` = `players`.`group_id` \
WHERE `players`.`name` = " + db->escapeString(name);
if(!(result = db->storeQuery(query.str()))){
return false;
}
query.str("");
player->setGUID(result->getDataInt("id"));
player->accountId = result->getDataInt("account_id");
player->groupName = result->getDataString("groupname");
player->accessLevel = result->getDataInt("access");
int32_t violationLevel = result->getDataInt("violation");
if(violationLevel > maxViolationLevel){
violationLevel = maxViolationLevel;
std::cout << "Warning: When loading player, maximum violation level is" << maxViolationLevel << std::endl;
}
player->violationLevel = violationLevel;
player->maxDepotLimit = result->getDataInt("maxdepotitems");
int32_t vipLimit = result->getDataInt("maxviplist");
if(vipLimit > 100){
vipLimit = 100;
std::cout << "Warning: When loading player, maximum size of VIP list is 100." << std::endl;
}
player->maxVipLimit = vipLimit;
player->setFlags(result->getDataLong("groupflags"));
if(preload){
//only loading basic info
db->freeResult(result);
return true;
}
// Getting all player properties
player->setSex((PlayerSex_t)result->getDataInt("sex"));
player->setDirection((Direction)result->getDataInt("direction"));
player->level = std::max((uint32_t)1, (uint32_t)result->getDataInt("level"));
uint64_t currExpCount = Player::getExpForLevel(player->level);
uint64_t nextExpCount = Player::getExpForLevel(player->level + 1);
uint64_t experience = (uint64_t)result->getDataLong("experience");
if(experience < currExpCount || experience > nextExpCount){
experience = currExpCount;
}
player->experience = experience;
player->levelPercent = Player::getPercentLevel(player->experience - currExpCount, nextExpCount - currExpCount);
player->soul = result->getDataInt("soul");
player->capacity = result->getDataInt("cap");
player->lastLoginSaved = result->getDataInt("lastlogin");
player->lastLogout = result->getDataInt("lastlogout");
player->health = result->getDataInt("health");
player->healthMax = result->getDataInt("healthmax");
loadOutfit(player, result);
#ifdef __SKULLSYSTEM__
int32_t skullType = result->getDataInt("skull_type");
int64_t lastSkullTime = result->getDataLong("skull_time");
if((skullType == SKULL_RED && std::time(NULL) < lastSkullTime + g_config.getNumber(ConfigManager::RED_SKULL_DURATION))){
player->lastSkullTime = lastSkullTime;
player->skullType = (Skulls_t)skullType;
}
#endif
loadConditions(player, result);
// you need to set the vocation after conditions in order to ensure the proper regeneration rates for the vocation
if(!player->setVocation(result->getDataInt("vocation"))){
return false;
}
// this stuff has to go after the vocation is set
player->mana = result->getDataInt("mana");
player->manaMax = result->getDataInt("manamax");
player->magLevel = result->getDataInt("maglevel");
uint64_t nextManaCount = (uint64_t)player->vocation->getReqMana(player->magLevel + 1);
uint64_t manaSpent = (uint64_t)result->getDataInt("manaspent");
if(manaSpent > nextManaCount){
//make sure its not out of bound
manaSpent = 0;
}
player->manaSpent = manaSpent;
player->magLevelPercent = Player::getPercentLevel(player->manaSpent, nextManaCount);
player->setLossPercent(LOSS_EXPERIENCE, result->getDataInt("loss_experience"));
player->setLossPercent(LOSS_MANASPENT, result->getDataInt("loss_mana"));
player->setLossPercent(LOSS_SKILLTRIES, result->getDataInt("loss_skills"));
player->setLossPercent(LOSS_ITEMS, result->getDataInt("loss_items"));
player->setLossPercent(LOSS_CONTAINERS, result->getDataInt("loss_containers"));
player->loginPosition.x = result->getDataInt("posx");
player->loginPosition.y = result->getDataInt("posy");
player->loginPosition.z = result->getDataInt("posz");
player->town = result->getDataInt("town_id");
Town* town = Towns::getInstance().getTown(player->town);
if(town){
player->masterPos = town->getTemplePosition();
}
//if posx == 0 AND posy == 0 AND posz == 0
// login position is temple position
Position loginPos = player->loginPosition;
if(loginPos.x == 0 && loginPos.y == 0 && loginPos.z == 0){
player->loginPosition = player->masterPos;
}
// place it here and now we can drop all additional query instances as all data were loaded
#ifdef __OLD_GUILD_SYSTEM__
uint32_t rankid = result->getDataInt("rank_id");
player->guildNick = result->getDataString("guildnick");
#endif
player->balance = result->getDataInt("balance");
db->freeResult(result);
//guild system
query.str("");
#ifdef __OLD_GUILD_SYSTEM__
query << "SELECT `guild_ranks`.`name` as `rank`, `guild_ranks`.`guild_id` as `guildid`, \
`guild_ranks`.`level` as `level`, `guilds`.`name` as `guildname` \
FROM `guild_ranks`, `guilds` \
WHERE `guild_ranks`.`id` = " << rankid << " AND `guild_ranks`.`guild_id` = `guilds`.`id`";
if((result = db->storeQuery(query.str()))){
Guild* guild = g_guilds.getGuildById(result->getDataInt("guildid"));
if(guild){
player->setGuild(guild);
player->guildRank = result->getDataString("rank");
player->guildLevel = result->getDataInt("level");
db->freeResult(result);
}
}
#else
query << "SELECT `guild_members`.`nick`, `guild_ranks`.`name`, `guild_ranks`.`level`, `guilds`.`id` \
FROM `guild_members` \
LEFT JOIN `guild_ranks` ON `guild_members`.`rank_id` = `guild_ranks`.`id` \
LEFT JOIN `guilds` ON `guilds`.`id` = `guild_ranks`.`guild_id` \
WHERE `guild_members`.`player_id` = " << player->getGUID();
if((result = db->storeQuery(query.str()))){
Guild* guild = g_guilds.getGuildById(result->getDataInt("id"));
if(guild){
player->setGuild(guild);
player->guildRank = result->getDataString("name");
player->guildLevel = result->getDataInt("level");
player->guildNick = result->getDataString("nick");
db->freeResult(result);
}
}
bool IOLoginData::loadPlayer(Player* player, const std::string& name, bool preload /*= false*/)
{
Database* db = Database::getInstance();
std::ostringstream query;
query << "SELECT `id`, `account_id`, `group_id`, `sex`, `vocation`, `experience`, `level`, `maglevel`, `health`, `healthmax`, `blessings`, `mana`, `manamax`, `manaspent`, `soul`, `lookbody`, `lookfeet`, `lookhead`, `looklegs`, `looktype`, `lookaddons`, `posx`, `posy`, `posz`, `cap`, `lastlogin`, `lastlogout`, `lastip`, `conditions`, `skulltime`, `skull`, `town_id`, `balance`, `offlinetraining_time`, `offlinetraining_skill`, `stamina` FROM `players` WHERE `name` = " << db->escapeString(name);
DBResult* result = db->storeQuery(query.str());
if (!result) {
return false;
}
uint32_t accno = result->getDataInt("account_id");
Account acc = loadAccount(accno);
player->setGUID(result->getDataInt("id"));
player->accountNumber = accno;
player->accountType = acc.accountType;
if (g_config.getBoolean(ConfigManager::FREE_PREMIUM)) {
player->premiumDays = 0xFFFF;
} else {
player->premiumDays = acc.premiumDays;
}
player->setGroupId(result->getDataInt("group_id"));
if (preload) {
//only loading basic info
db->freeResult(result);
return true;
}
player->bankBalance = (uint64_t)result->getDataLong("balance");
player->setSex((PlayerSex_t)result->getDataInt("sex"));
player->level = std::max<uint32_t>(1, result->getDataInt("level"));
uint64_t currExpCount = Player::getExpForLevel(player->level);
uint64_t nextExpCount = Player::getExpForLevel(player->level + 1);
uint64_t experience = (uint64_t)result->getDataLong("experience");
if (experience < currExpCount || experience > nextExpCount) {
experience = currExpCount;
}
player->experience = experience;
if (currExpCount < nextExpCount) {
player->levelPercent = Player::getPercentLevel(player->experience - currExpCount, nextExpCount - currExpCount);
} else {
player->levelPercent = 0;
}
player->soul = result->getDataInt("soul");
player->capacity = result->getDataInt("cap");
player->blessings = result->getDataInt("blessings");
unsigned long conditionsSize = 0;
const char* conditions = result->getDataStream("conditions", conditionsSize);
PropStream propStream;
propStream.init(conditions, conditionsSize);
Condition* condition = Condition::createCondition(propStream);
while (condition) {
if (condition->unserialize(propStream)) {
player->storedConditionList.push_back(condition);
} else {
delete condition;
}
condition = Condition::createCondition(propStream);
}
player->setVocation(result->getDataInt("vocation"));
player->mana = result->getDataInt("mana");
player->manaMax = result->getDataInt("manamax");
player->magLevel = result->getDataInt("maglevel");
uint64_t nextManaCount = player->vocation->getReqMana(player->magLevel + 1);
uint64_t manaSpent = result->getDataLong("manaspent");
if (manaSpent > nextManaCount) {
manaSpent = 0;
}
player->manaSpent = manaSpent;
player->magLevelPercent = Player::getPercentLevel(player->manaSpent,
nextManaCount);
player->health = result->getDataInt("health");
player->healthMax = result->getDataInt("healthmax");
player->defaultOutfit.lookType = result->getDataInt("looktype");
player->defaultOutfit.lookHead = result->getDataInt("lookhead");
player->defaultOutfit.lookBody = result->getDataInt("lookbody");
player->defaultOutfit.lookLegs = result->getDataInt("looklegs");
player->defaultOutfit.lookFeet = result->getDataInt("lookfeet");
player->defaultOutfit.lookAddons = result->getDataInt("lookaddons");
player->currentOutfit = player->defaultOutfit;
if (g_game.getWorldType() != WORLD_TYPE_PVP_ENFORCED) {
int32_t skullSeconds = result->getDataInt("skulltime") - time(NULL);
if (skullSeconds > 0) {
//ensure that we round up the number of ticks
player->skullTicks = (skullSeconds + 2) * 1000;
int32_t skull = result->getDataInt("skull");
if (skull == SKULL_RED) {
player->skull = SKULL_RED;
} else if (skull == SKULL_BLACK) {
player->skull = SKULL_BLACK;
}
}
}
player->loginPosition.x = result->getDataInt("posx");
player->loginPosition.y = result->getDataInt("posy");
player->loginPosition.z = result->getDataInt("posz");
player->lastLoginSaved = result->getDataLong("lastlogin");
player->lastLogout = result->getDataLong("lastlogout");
player->offlineTrainingTime = result->getDataInt("offlinetraining_time") * 1000;
player->offlineTrainingSkill = result->getDataInt("offlinetraining_skill");
player->town = result->getDataInt("town_id");
Town* town = Towns::getInstance().getTown(player->town);
if (town) {
player->masterPos = town->getTemplePosition();
}
Position loginPos = player->loginPosition;
if (loginPos.x == 0 && loginPos.y == 0 && loginPos.z == 0) {
player->loginPosition = player->masterPos;
}
player->staminaMinutes = result->getDataInt("stamina");
db->freeResult(result);
query.str("");
query << "SELECT `guild_id`, `rank_id`, `nick` FROM `guild_membership` WHERE `player_id` = " << player->getGUID();
if ((result = db->storeQuery(query.str()))) {
uint32_t guildId = result->getDataInt("guild_id");
uint32_t playerRankId = result->getDataInt("rank_id");
player->guildNick = result->getDataString("nick");
db->freeResult(result);
Guild* guild = g_game.getGuild(guildId);
if (!guild) {
query.str("");
query << "SELECT `name` FROM `guilds` WHERE `id` = " << guildId;
if ((result = db->storeQuery(query.str()))) {
guild = new Guild(guildId, result->getDataString("name"));
db->freeResult(result);
g_game.addGuild(guild);
query.str("");
query << "SELECT `id`, `name`, `level` FROM `guild_ranks` WHERE `guild_id` = " << guildId << " LIMIT 3";
if ((result = db->storeQuery(query.str()))) {
do {
guild->addRank(result->getDataInt("id"), result->getDataString("name"), result->getDataInt("level"));
} while (result->next());
db->freeResult(result);
}
}
}
if (guild) {
player->guild = guild;
GuildRank* rank = guild->getRankById(playerRankId);
if (rank) {
player->guildLevel = rank->level;
} else {
player->guildLevel = 1;
}
IOGuild::getInstance()->getWarList(guildId, player->guildWarList);
query.str("");
query << "SELECT COUNT(*) AS `members` FROM `guild_membership` WHERE `guild_id` = " << guildId;
if ((result = db->storeQuery(query.str()))) {
guild->setMemberCount(result->getDataInt("members"));
db->freeResult(result);
}
}
}
//get password
query.str("");
query << "SELECT `password` FROM `accounts` WHERE `id` = " << accno;
result = db->storeQuery(query.str());
if (!result) {
return false;
}
player->password = result->getDataString("password");
db->freeResult(result);
// we need to find out our skills
// so we query the skill table
query.str("");
query << "SELECT `skillid`, `value`, `count` FROM `player_skills` WHERE `player_id` = " << player->getGUID();
if ((result = db->storeQuery(query.str()))) {
//now iterate over the skills
do {
int32_t skillid = result->getDataInt("skillid");
if (skillid >= SKILL_FIRST && skillid <= SKILL_LAST) {
uint32_t skillLevel = result->getDataInt("value");
uint64_t skillCount = result->getDataLong("count");
uint64_t nextSkillCount = player->vocation->getReqSkillTries(skillid, skillLevel + 1);
if (skillCount > nextSkillCount) {
skillCount = 0;
}
player->skills[skillid][SKILL_LEVEL] = skillLevel;
player->skills[skillid][SKILL_TRIES] = skillCount;
player->skills[skillid][SKILL_PERCENT] = Player::getPercentLevel(skillCount, nextSkillCount);
}
} while (result->next());
db->freeResult(result);
}
query.str("");
query << "SELECT `player_id`, `name` FROM `player_spells` WHERE `player_id` = " << player->getGUID();
if ((result = db->storeQuery(query.str()))) {
do {
std::string spellName = result->getDataString("name");
player->learnedInstantSpellList.push_back(spellName);
} while (result->next());
db->freeResult(result);
}
//load inventory items
ItemMap itemMap;
query.str("");
query << "SELECT `pid`, `sid`, `itemtype`, `count`, `attributes` FROM `player_items` WHERE `player_id` = " << player->getGUID() << " ORDER BY `sid` DESC";
if ((result = db->storeQuery(query.str()))) {
loadItems(itemMap, result);
db->freeResult(result);
for (ItemMap::reverse_iterator it = itemMap.rbegin(); it != itemMap.rend(); ++it) {
const std::pair<Item*, int32_t>& pair = it->second;
Item* item = pair.first;
int32_t pid = pair.second;
if (pid >= 1 && pid <= 10) {
player->__internalAddThing(pid, item);
} else {
ItemMap::const_iterator it2 = itemMap.find(pid);
if (it2 == itemMap.end()) {
continue;
}
Container* container = it2->second.first->getContainer();
if (container) {
container->__internalAddThing(item);
}
}
}
}
//load depot items
itemMap.clear();
query.str("");
query << "SELECT `pid`, `sid`, `itemtype`, `count`, `attributes` FROM `player_depotitems` WHERE `player_id` = " << player->getGUID() << " ORDER BY `sid` DESC";
if ((result = db->storeQuery(query.str()))) {
loadItems(itemMap, result);
db->freeResult(result);
for (ItemMap::reverse_iterator it = itemMap.rbegin(); it != itemMap.rend(); ++it) {
const std::pair<Item*, int32_t>& pair = it->second;
Item* item = pair.first;
int32_t pid = pair.second;
if (pid >= 0 && pid < 100) {
DepotChest* depotChest = player->getDepotChest(pid, true);
if (depotChest) {
depotChest->__internalAddThing(item);
}
} else {
ItemMap::const_iterator it2 = itemMap.find(pid);
if (it2 == itemMap.end()) {
continue;
}
Container* container = it2->second.first->getContainer();
if (container) {
container->__internalAddThing(item);
}
}
}
}
//load inbox items
itemMap.clear();
query.str("");
query << "SELECT `pid`, `sid`, `itemtype`, `count`, `attributes` FROM `player_inboxitems` WHERE `player_id` = " << player->getGUID() << " ORDER BY `sid` DESC";
if ((result = db->storeQuery(query.str()))) {
loadItems(itemMap, result);
db->freeResult(result);
for (ItemMap::reverse_iterator it = itemMap.rbegin(); it != itemMap.rend(); ++it) {
const std::pair<Item*, int32_t>& pair = it->second;
Item* item = pair.first;
int32_t pid = pair.second;
if (pid >= 0 && pid < 100) {
player->getInbox()->__internalAddThing(item);
} else {
ItemMap::const_iterator it2 = itemMap.find(pid);
if (it2 == itemMap.end()) {
continue;
}
Container* container = it2->second.first->getContainer();
if (container) {
container->__internalAddThing(item);
}
}
}
}
//load storage map
query.str("");
query << "SELECT `key`, `value` FROM `player_storage` WHERE `player_id` = " << player->getGUID();
if ((result = db->storeQuery(query.str()))) {
do {
player->addStorageValue(result->getDataInt("key"), result->getDataLong("value"), true);
} while (result->next());
db->freeResult(result);
}
//load vip
query.str("");
query << "SELECT `player_id` FROM `account_viplist` WHERE `account_id` = " << player->getAccount();
if ((result = db->storeQuery(query.str()))) {
do {
player->addVIPInternal(result->getDataInt("player_id"));
} while (result->next());
db->freeResult(result);
}
player->updateBaseSpeed();
player->updateInventoryWeight();
player->updateItemsLight(true);
return true;
}
