bool Party::setSharedExperience(Player* player, bool _sharedExpActive)
{
if (!player || getLeader() != player)
{
return false;
}
if (sharedExpActive == _sharedExpActive)
{
return true;
}
sharedExpActive = _sharedExpActive;
if (sharedExpActive)
{
sharedExpEnabled = canEnableSharedExperience();
if (sharedExpEnabled)
{
getLeader()->sendTextMessage(MSG_INFO_DESCR, "Shared Experience is now active.");
}
else
{
getLeader()->sendTextMessage(MSG_INFO_DESCR, "Shared Experience has been activated," \
" but some members of your party are inactive.");
}
}
else
{
getLeader()->sendTextMessage(MSG_INFO_DESCR, "Shared Experience has been deactivated.");
}
updateAllPartyIcons();
return true;
}
void Party::broadcastMessage(MessageClasses messageClass, const std::string& text, bool sendToInvitations/* = false*/)
{
PlayerVector::iterator it;
if(!memberList.empty())
{
for(it = memberList.begin(); it != memberList.end(); ++it)
(*it)->sendTextMessage(messageClass, text);
}
getLeader()->sendTextMessage(messageClass, text);
if(sendToInvitations && !inviteList.empty())
{
for(it = inviteList.begin(); it != inviteList.end(); ++it)
(*it)->sendTextMessage(messageClass, text);
}
}
bool Party::canEnableSharedExperience()
{
if (!canUseSharedExperience(getLeader()))
{
return false;
}
for (PlayerVector::iterator it = memberList.begin(); it != memberList.end(); ++it)
{
if (!canUseSharedExperience(*it))
{
return false;
}
}
return true;
}
void Party::shareExperience(const uint64_t& experience, bool fromMonster)
{
double member_factor = g_config.getNumber(ConfigManager::PARTY_MEMBER_EXP_BONUS);
double xpgained = (experience + (experience * (member_factor / 100.))) / (memberList.size() + 1);
if (xpgained < 0)
{
return;
}
uint64_t shareExp = (uint64_t)std::ceil(xpgained);
for (PlayerVector::iterator it = memberList.begin(); it != memberList.end(); ++it)
{
(*it)->onGainSharedExperience(shareExp, fromMonster);
}
getLeader()->onGainSharedExperience(shareExp, fromMonster);
}
void GroupObjectImplementation::removeGroupModifiers(CreatureObject* player) {
if (player == NULL)
return;
Reference<CreatureObject*> leader = getLeader();
if (leader == NULL)
return;
if (!leader->isPlayerCreature())
return;
Locker clocker(player, _this.getReferenceUnsafeStaticCast());
String action = "squadleader";
if (player->hasBuff(action.hashCode()))
player->removeBuff(action.hashCode());
player->updateTerrainNegotiation();
}
bool TeamManager::canPutSkill()
{
SceneUser *leader = SceneUserManager::getMe().getUserByTempID(getLeader());
if (leader)
{
CheckAllInOneScreenExec exec(leader);
execEveryOne(exec);
if (!exec.isOk)
{
if (!giveupstatus)
{
giveupstatus = true;
giveuptime.now();
giveuptime.addDelay(120000);
return true;
}
else
{
if (SceneTimeTick::currentTime.msecs() > giveuptime.msecs())
{
giveupstatus = false;///将状态初始化回去。
return false;
}
else
return true;
}
}
else
{
giveupstatus = false;
return true;
}
}
return false;
}
void GroupObject::removeMember(Player* player)
{
PlayerList::iterator listIt = mMembers.begin();
while(listIt != mMembers.end())
{
// find the player to remove
if((*listIt) == player)
{
// remove player from the group channel
if(mChannel)
{
mChannel->removeUser(player);
gChatMessageLib->sendChatOnDestroyRoom(player->getClient(), mChannel, 0);
}
player->setGroupId(0);
// if he is the last member
if(mMembers.size() <= 2)
{
disband();
break;
}
// tell the zone to send the groupId delta
// FIXME: player's network client is already dead!!
gChatMessageLib->sendIsmGroupCREO6deltaGroupId(0, player);
// remove from list
mMembers.erase(listIt);
broadcastDeltaRemove(player);
// if player was the leader
if(player->getGroupMemberIndex() == 0)
{
// TODO: delegate zone for handling inrange sys messages
gChatMessageLib->sendGroupSystemMessage(getLeader()->getName(), BString("new_leader"), NULL, this, true);
}
else // if he wasnt leader,
{
// but was Master Looter
if(player->getCharId() == mMasterLooter)
{
// give MasterLootership to the new leader
this->changeMasterLooter(getLeader());
}
}
// recalculate indexes
resetIndexes();
gChatMessageLib->sendSystemMessage(player,L"@group:removed");
// minus minus
mMemberCount--;
// lets get out of this!
break;
}
++listIt;
}
}
/**
* Create a VG grpah from a pinch thread set.
*/
vg::VG pinchToVG(stPinchThreadSet* threadSet, std::map<int64_t, std::string>& threadSequences) {
// Make an empty graph
vg::VG graph;
// Remember what nodes have been created for what segments. Only the first
// segment in a block (the "leader") gets a node. Segments without blocks
// are also themselves leaders and get nodes.
std::map<stPinchSegment*, vg::Node*> nodeForLeader;
std::cerr << "Making pinch graph into vg graph with " << threadSequences.size() << " relevant threads" << std::endl;
// This is the cleverest way to loop over Benedict's iterators.
auto segmentIterator = stPinchThreadSet_getSegmentIt(threadSet);
while(auto segment = stPinchThreadSetSegmentIt_getNext(&segmentIterator)) {
// For every segment, we need to make a VG node for it or its block (if
// it has one).
#ifdef debug
std::cerr << "Found segment " << segment << std::endl;
#endif
// See if the segment is in a block
auto block = stPinchSegment_getBlock(segment);
// Get the leader segment: first in the block, or this segment if no block
auto leader = getLeader(segment);
if(nodeForLeader.count(leader)) {
// A node has already been made for this block.
continue;
}
// Otherwise, we need the sequence
std::string sequence;
if(block) {
// Get the sequence by scanning through the block for the first sequence
// that isn't all Ns, if any.
auto segmentIterator = stPinchBlock_getSegmentIterator(block);
while(auto sequenceSegment = stPinchBlockIt_getNext(&segmentIterator)) {
if(!threadSequences.count(stPinchSegment_getName(sequenceSegment))) {
// This segment is part of a staple. Pass it up
continue;
}
// Go get the sequence of the thread, and clip out the part relevant to this segment.
sequence = threadSequences.at(stPinchSegment_getName(sequenceSegment)).substr(
stPinchSegment_getStart(sequenceSegment), stPinchSegment_getLength(sequenceSegment));
// If necessary, flip the segment around
if(getOrientation(sequenceSegment)) {
sequence = vg::reverse_complement(sequence);
}
if(std::count(sequence.begin(), sequence.end(), 'N') +
std::count(sequence.begin(), sequence.end(), 'n') < sequence.size()) {\
// The sequence has some non-N characters
// If it's not all Ns, break
break;
}
// Otherwise try the next segment
}
} else {
// Just pull the sequence from the lone segment
sequence = threadSequences.at(stPinchSegment_getName(segment)).substr(
stPinchSegment_getStart(segment), stPinchSegment_getLength(segment));
// It doesn't need to flip, since it can't be backwards in a block
}
// Make a node in the graph to represent the block
vg::Node* node = graph.create_node(sequence);
// Remember it
nodeForLeader[leader] = node;
#ifdef debug
std::cerr << "Made node: " << pb2json(*node) << std::endl;
#endif
}
// Now go through the segments again and wire them up.
segmentIterator = stPinchThreadSet_getSegmentIt(threadSet);
while(auto segment = stPinchThreadSetSegmentIt_getNext(&segmentIterator)) {
// See if the segment is in a block
auto block = stPinchSegment_getBlock(segment);
// Get the leader segment: first in the block, or this segment if no block
auto leader = getLeader(segment);
// We know we have a node already
auto node = nodeForLeader.at(leader);
// What orientation is this node in for the purposes of this edge
// TODO: ought to always be false if the segment isn't in a block. Is this true?
auto orientation = getOrientation(segment);
#ifdef debug
std::cerr << "Revisited segment: " << segment << " for node " << node->id() <<
" in orientation " << (orientation ? "reverse" : "forward") << std::endl;
#endif
// Look at the segment 5' of here. We know it's not a staple and
// thus has a vg node.
auto prevSegment = stPinchSegment_get5Prime(segment);
if(prevSegment) {
// Get the node IDs and orientations
auto prevNode = nodeForLeader.at(getLeader(prevSegment));
auto prevOrientation = getOrientation(prevSegment);
#ifdef debug
std::cerr << "Found prev node " << prevNode->id() << " in orientation " <<
(prevOrientation ? "reverse" : "forward") << std::endl;
#endif
// Make an edge
vg::Edge prevEdge;
prevEdge.set_from(prevNode->id());
prevEdge.set_from_start(prevOrientation);
prevEdge.set_to(node->id());
prevEdge.set_to_end(orientation);
// Add it in. vg::VG deduplicates for us
graph.add_edge(prevEdge);
#ifdef debug
std::cerr << "Made edge: " << pb2json(prevEdge) << std::endl;
#endif
}
// Now do the same thing for the 3' side
auto nextSegment = stPinchSegment_get3Prime(segment);
if(nextSegment) {
// Get the node IDs and orientations
auto nextNode = nodeForLeader.at(getLeader(nextSegment));
auto nextOrientation = getOrientation(nextSegment);
#ifdef debug
std::cerr << "Found next node " << nextNode->id() << " in orientation " <<
(nextOrientation ? "reverse" : "forward") << std::endl;
#endif
// Make an edge
vg::Edge nextEdge;
nextEdge.set_from(node->id());
nextEdge.set_from_start(orientation);
nextEdge.set_to(nextNode->id());
nextEdge.set_to_end(nextOrientation);
// Add it in. vg::VG deduplicates for us
graph.add_edge(nextEdge);
#ifdef debug
std::cerr << "Made edge: " << pb2json(nextEdge) << std::endl;
#endif
}
}
// Spit out the graph.
return graph;
}
bool Party::leaveParty(Player* player)
{
if(!player){
return false;
}
if(!isPlayerMember(player) && getLeader() != player){
return false;
}
// Remove from chat
PrivateChatChannel* pcc = static_cast<PrivateChatChannel*>(g_chat.getChannel(this));
if(pcc){
pcc->removeUser(player, true);
}
bool hasNoLeader = false;
if(getLeader() == player){
if(!memberList.empty()){
if(memberList.size() == 1 && inviteList.empty()){
//just one member left, disband instead of passing leadership
hasNoLeader = true;
}
else{
passPartyLeadership(memberList.front());
}
}
else{
hasNoLeader = true;
}
}
//since we already passed the leadership, we remove the player from the list
PlayerVector::iterator it = std::find(memberList.begin(), memberList.end(), player);
if(it != memberList.end()){
memberList.erase(it);
}
it = std::find(inviteList.begin(), inviteList.end(), player);
if(it != inviteList.end()){
inviteList.erase(it);
}
player->setParty(NULL);
player->sendTextMessage(MSG_INFO_DESCR, "You have left the party.");
player->sendPlayerPartyIcons(player);
updateSharedExperience();
updatePartyIcons(player);
clearPlayerPoints(player);
std::stringstream ss;
ss << player->getName() << " has left the party.";
broadcastPartyMessage(MSG_INFO_DESCR, ss.str());
if(hasNoLeader || disbandParty()){
disband();
}
return true;
}
