boost::shared_ptr< const MapsBuffer::MapsRgb >
MapsBuffer::getFront(bool print)
{
boost::shared_ptr< const MapsBuffer::MapsRgb > depth_rgb;
{
boost::mutex::scoped_lock buff_lock (bmutex_);
while (buffer_.empty ())
{
if (is_done)
break;
{
boost::mutex::scoped_lock io_lock (io_mutex);
//std::cout << "No data in buffer_ yet or buffer is empty." << std::endl;
}
buff_empty_.wait (buff_lock);
}
depth_rgb = buffer_.front ();
buffer_.pop_front ();
}
if(print)
PCL_INFO("%d maps left in the buffer...\n", buffer_.size ());
return (depth_rgb);
}
bool
PCDBuffer::pushBack (pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr cloud)
{
bool retVal = false;
{
boost::mutex::scoped_lock buff_lock (bmutex_);
if (!buffer_.full ())
retVal = true;
buffer_.push_back (cloud);
}
buff_empty_.notify_one ();
return (retVal);
}
bool
MapsBuffer::pushBack(boost::shared_ptr<const MapsRgb> maps_rgb )
{
bool retVal = false;
{
boost::mutex::scoped_lock buff_lock (bmutex_);
if (!buffer_.full ())
retVal = true;
buffer_.push_back (maps_rgb);
}
buff_empty_.notify_one ();
return (retVal);
}
pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr
PCDBuffer::getFront ()
{
pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr cloud;
{
boost::mutex::scoped_lock buff_lock (bmutex_);
while (buffer_.empty ())
{
if (is_done)
break;
{
boost::mutex::scoped_lock io_lock (io_mutex);
//std::cout << "No data in buffer_ yet or buffer is empty." << std::endl;
}
buff_empty_.wait (buff_lock);
}
cloud = buffer_.front ();
buffer_.pop_front ();
}
return (cloud);
}
inline bool
isFull ()
{
boost::mutex::scoped_lock buff_lock (bmutex_);
return (buffer_.full ());
}
inline void
setCapacity (int buff_size)
{
boost::mutex::scoped_lock buff_lock (bmutex_);
buffer_.set_capacity (buff_size);
}
inline int
getSize ()
{
boost::mutex::scoped_lock buff_lock (bmutex_);
return (int (buffer_.size ()));
}
inline bool
isEmpty ()
{
boost::mutex::scoped_lock buff_lock (bmutex_);
return (buffer_.empty ());
}
void ICharacter::calculateStats ()
{
boost::unique_lock<boost::mutex> statsLock(m_stats_mutex);
boost::mutex::scoped_lock property_lock(m_property_mutex);
/// SET BASE STATS AND RECALCULATE
m_MA = std::make_pair(0,0);
m_PA = std::make_pair(0,0);
m_PAbs = 0;
m_MAbs = 0;
m_PD = m_property->PhysicalDefense;
m_MD = m_property->MagicalDefense;
m_BR = m_property->BlockRatio;
m_CR = 0;
m_PR = m_property->ParryRatio;
m_HR = m_property->HitRatio;
m_PBalance = 0;
m_MBalance = 0;
m_PRate = 0;
m_MRate = 0;
m_AD = 0;
float wlkspeed = m_property->WalkSpeed;
float runspeed = m_property->RunSpeed;
float bskspeed = m_property->BersekSpeed;
property_lock.unlock();
bool hasWall = false;
uint32_t curWallHP = m_Effects[STAT_WALL_HP];
m_Effects.clear();
short speed_percent = 0;
short hp_percent = 0;
short mp_percent = 0;
short pr_percent = 0;
short hr_percent = 0;
short pd_percent = 0;
short md_percent = 0;
std::vector<std::pair<CHAR_STATS,int32_t> > bonus;
calculatePreStats(bonus);
boost::mutex::scoped_lock buff_lock(m_buff_mutex);
for ( std::map<uint32_t,Buff>::const_iterator k = m_buff_list.begin(); k != m_buff_list.end(); ++k)
{
for (Skill::buff_const_iterator j = k->second.skill->buff_begin(); j != k->second.skill->buff_end(); ++j)
{
switch(j->ID)
{
case BUFF_CRITICAL_INC:
m_CR += j->Arg[0];
break;
case BUFF_SPEED_INC:
case BUFF_SPEED_INC2:
case BUFF_SPEED_INC3:
speed_percent += j->Arg[0];
break;
case BUFF_PARRY_INC:
m_PR += j->Arg[0];
pr_percent += j->Arg[1];
break;
case BUFF_PARRY_DEC:
m_PR -= j->Arg[0];
break;
case BUFF_HIT_INC:
m_HR += j->Arg[0];
hr_percent += j->Arg[1];
break;
case BUFF_HIT_DEC:
m_HR -= j->Arg[0];
break;
case BUFF_HP_INC:
m_MaxHP += j->Arg[0];
hp_percent += j->Arg[1];
break;
case BUFF_MP_INC:
m_MaxMP += j->Arg[0];
mp_percent += j->Arg[1];
break;
case BUFF_RANGE_INC:
m_AD += j->Arg[0];
break;
case BUFF_DAMAGE_INC:
m_PRate += j->Arg[0];
m_MRate += j->Arg[0];
break;
case BUFF_INT_INC:
case BUFF_STR_INC:
case BUFF_SHIELD_PWR_4_DAMAGE:
calculateBuffEffects(bonus,*j);
break;
case BUFF_REINCARNATION:
m_Effects[STAT_HP_RGN] += j->Arg[0];
m_Effects[STAT_MP_RGN] += j->Arg[1];
break;
case BUFF_IGNORE_DEFENSE:
m_Effects[STAT_IGD] += j->Arg[0];
break;
case BUFF_CRIT_PARRY_INC:
m_Effects[STAT_CPR] += j->Arg[0];
break;
case BUFF_GOLD_DROP_INC:
m_Effects[STAT_GOLD_DROP] += j->Arg[0];
break;
case BUFF_MAGICOPTION_LUCK_INC:
m_Effects[STAT_MOL] += j->Arg[0];
break;
case BUFF_ENCHANT_LUCK_INC:
m_Effects[STAT_ETL] += j->Arg[0];
break;
case BUFF_MP_ABSORB:
m_Effects[STAT_MP_ABSORB] += j->Arg[0];
break;
case BUFF_DAMAGE_PWR_INC:
m_PA.first += j->Arg[0];
m_PA.second += j->Arg[0];
m_MA.first += j->Arg[1];
m_MA.second += j->Arg[1];
break;
case BUFF_DETECT:
case BUFF_DETECT_V2:
//(5 Stealth) (6 Invisible) (7 All)
//Max level
break;
case BUFF_HEAL_INC:
m_Effects[STAT_HP_HEAL] += j->Arg[0];
m_Effects[STAT_MP_HEAL] += j->Arg[1];
break;
case BUFF_ABSORB_WALL:
hasWall = true;
m_Effects[STAT_WALL] = j->Arg[0] == WALL_TYPE_PHYSICAL;
m_Effects[STAT_WALL_MAX] = j->Arg[1];
m_Effects[STAT_WALL_RATE] = j->Arg[3];
m_Effects[STAT_WALL_ID] = k->first;
break;
case BUFF_BLOCK_INC:
//BLOCK TYPE +0 (15 ALL) (11 Magic %) (7 Physical %)
//BLOCK RATE +1
m_BR += j->Arg[1];
break;
case BUFF_DAMAGE_REFLECT:
//PROBABILITY [%]
//PHY DAMAGE RETURNED [%]
//MAG DAMAGE RETURNED [%]
//RETURN RANGE
break;
case BUFF_ABSORB:
//TYPE (3 - Physical Absorb) (12 & 15 - Absorb all) (4 Physical) (8 Magical) (6 Physical ranged)
//Amount (%)
//0
break;
case BUFF_DEFENSE_INC:
m_PD += j->Arg[0];
m_MD += j->Arg[1];
//Caster Range
break;
case BUFF_DEFENSE_DEC:
pd_percent -= j->Arg[0];
md_percent -= j->Arg[1];
break;
case BUFF_DAMAGE_DEC:
m_PRate -= j->Arg[0];
m_MRate -= j->Arg[1];
break;
case BUFF_HP_DEC:
//Duration
//0
hp_percent -= j->Arg[2];
//2
break;
default:
break;
}
}
}
if (hasWall)
{
uint32_t wallMax = m_Effects[STAT_WALL_MAX];
if (curWallHP > wallMax)
m_Effects[STAT_WALL_HP] = wallMax;
}
buff_lock.unlock();
for (std::vector<std::pair<CHAR_STATS,int32_t> >::const_iterator it = bonus.begin(); it != bonus.end(); ++it)
{
switch(it->first)
{
case STAT_HP_PERCENT:
hp_percent += it->second;
break;
case STAT_HR_PERCENT:
hr_percent += it->second;
break;
case STAT_MP_PERCENT:
mp_percent += it->second;
break;
case STAT_PR_PERCENT:
pr_percent += it->second;
break;
default:
break;
}
}
calculatePostStats();
if (hp_percent)
m_MaxHP = linear_regression(m_MaxHP,hp_percent);
if (m_HP > m_MaxHP)
m_HP = m_MaxHP;
if (mp_percent)
m_MaxMP = linear_regression(m_MaxMP,mp_percent);
if (m_MP > m_MaxMP)
m_MP = m_MaxMP;
if (pr_percent)
m_PR = linear_regression(m_PR,pr_percent);
if (hr_percent)
m_HR = linear_regression(m_HR,hr_percent);
if (pd_percent)
m_PD = linear_regression(m_PD,pd_percent);
if (md_percent)
m_MD = linear_regression(m_MD,md_percent);
if (speed_percent)
{
wlkspeed = linear_regression(wlkspeed,speed_percent);
runspeed = linear_regression(runspeed,speed_percent);
bskspeed = linear_regression(bskspeed,speed_percent);
}
if (IsBerserk())
{
wlkspeed *=2;
runspeed *=2;
bskspeed *=2;
m_PA.first *= 2;
m_PA.second *= 2;
m_MA.first *= 2;
m_MA.second *= 2;
}
m_WalkSpeed = wlkspeed;
m_RunSpeed = runspeed;
m_BerserkSpeed = bskspeed;
calculateStatus();
statsLock.unlock();
if (!signal_stats.empty())
signal_stats();
if (!signal_speed.empty())
signal_speed(m_WalkSpeed,m_RunSpeed);
}
