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