void SceneObjectImplementation::updateDirection(float angleHeadingRadians) {
setDirection(angleHeadingRadians);
++movementCounter;
if (parent.get() != NULL) {
DataTransformWithParent* pack = new DataTransformWithParent(asSceneObject());
broadcastMessage(pack, true, true);
} else {
DataTransform* pack = new DataTransform(asSceneObject());
broadcastMessage(pack, true, true);
}
}
void TangibleObjectImplementation::addDefender(SceneObject* defender) {
if (defender == asTangibleObject())
return;
assert(defender);
for (int i = 0; i < defenderList.size(); ++i) {
if (defender == defenderList.get(i))
return;
}
//info("adding defender");
TangibleObjectDeltaMessage6* dtano6 = new TangibleObjectDeltaMessage6(asTangibleObject());
dtano6->startUpdate(0x01);
defenderList.add(defender, dtano6);
dtano6->close();
broadcastMessage(dtano6, true);
setCombatState();
notifyObservers(ObserverEventType::DEFENDERADDED, defender);
}
void GameServer::handleDisconnections()
{
for (auto itr = mPeers.begin(); itr != mPeers.end(); )
{
if ((*itr)->timedOut)
{
// Inform everyone of the disconnection, erase
for (sf::Int32 identifier : (*itr)->aircraftIdentifiers)
{
sendToAll(sf::Packet() << static_cast<sf::Int32>(Server::PlayerDisconnect) << identifier);
mAircraftInfo.erase(identifier);
}
mConnectedPlayers--;
mAircraftCount -= (*itr)->aircraftIdentifiers.size();
itr = mPeers.erase(itr);
// Go back to a listening state if needed
if (mConnectedPlayers < mMaxConnectedPlayers)
{
mPeers.push_back(PeerPtr(new RemotePeer()));
setListening(true);
}
broadcastMessage("An ally has disconnected.");
}
else
{
++itr;
}
}
}
void SceneObjectImplementation::playEffect(const String& file,
const String& aux) {
PlayClientEffectObjectMessage* effect = new PlayClientEffectObjectMessage(
asSceneObject(), file, aux);
broadcastMessage(effect, true);
}
void TangibleObjectImplementation::removeDefender(SceneObject* defender) {
//info("trying to remove defender");
for (int i = 0; i < defenderList.size(); ++i) {
if (defenderList.get(i) == defender) {
info("removing defender");
notifyObservers(ObserverEventType::DEFENDERDROPPED, defender);
TangibleObjectDeltaMessage6* dtano6 = new TangibleObjectDeltaMessage6(asTangibleObject());
dtano6->startUpdate(0x01);
if (defenderList.size() == 1)
defenderList.removeAll(dtano6);
else
defenderList.remove(i, dtano6);
dtano6->close();
broadcastMessage(dtano6, true);
//info("defender found and removed");
break;
}
}
if (defenderList.size() == 0)
clearCombatState(false);
//info("finished removing defender");
}
void TcpServer::broadcastMessage(ClientResponse* message) {
char* json = MessageConversion::convertResponseToJson(message, true);
if (json != nullptr) {
broadcastMessage(json);
}
delete[] json;
}
bool Party::passLeadership(Player* player)
{
if(!player || getLeader() == player || !isPlayerMember(player))
return false;
//Remove it before to broadcast the message correctly
PlayerVector::iterator it = std::find(memberList.begin(), memberList.end(), player);
if(it != memberList.end())
memberList.erase(it);
Player* oldLeader = getLeader();
setLeader(player);
memberList.insert(memberList.begin(), oldLeader);
char buffer[125];
sprintf(buffer, "%s is now the leader of the party.", player->getName().c_str());
broadcastMessage(MSG_INFO_DESCR, buffer, true);
player->sendTextMessage(MSG_INFO_DESCR, "You are now the leader of the party.");
updateSharedExperience();
updateIcons(oldLeader);
updateIcons(player);
return true;
}
void HooksUpdateDetector::terminate32Loader()
{
if (m_hookLoader32.getProcessHandle() != 0) {
// Send broadcast message to close the 32 bit hook loader.
broadcastMessage(HookDefinitions::LOADER_CLOSE_CODE);
}
}
void GroupObjectImplementation::calcGroupLevel() {
int highestPlayer = 0;
groupLevel = 0;
for (int i = 0; i < getGroupSize(); i++) {
Reference<SceneObject*> member = getGroupMember(i);
if (member->isPet()) {
CreatureObject* creature = cast<CreatureObject*>(member.get());
groupLevel += creature->getLevel() / 5;
} else if (member->isPlayerCreature()) {
CreatureObject* creature = cast<CreatureObject*>(member.get());
int memberLevel = creature->getLevel();
if (memberLevel > highestPlayer) {
groupLevel += (memberLevel - highestPlayer + (highestPlayer / 5));
highestPlayer = memberLevel;
} else {
groupLevel += memberLevel / 5;
}
}
}
GroupObjectDeltaMessage6* msg = new GroupObjectDeltaMessage6(_this.getReferenceUnsafeStaticCast());
msg->updateLevel(this->groupLevel);
msg->close();
broadcastMessage(msg);
}
void RDOKernel::unregistered( RDOThread* thread )
{
#ifdef RDO_MT
threads_mutex.Lock();
#endif
if ( thread && std::find( threads.begin(), threads.end(), thread ) != threads.end() ) {
threads.remove( thread );
} else {
#ifdef RDO_MT
threads_mutex.Unlock();
#endif
return;
}
if ( thread_runtime && thread->getName() == "RDOThreadRunTime" ) thread_runtime = NULL;
if ( thread_simulator && thread->getName() == "RDOThreadSimulator" ) thread_simulator = NULL;
if ( thread_codecomp && thread->getName() == "RDOThreadCodeComp" ) thread_codecomp = NULL;
if ( thread_repository && thread->getName() == "RDOThreadRepository" ) thread_repository = NULL;
#ifdef CORBA_ENABLE
if ( thread_corba && thread->getName() == "RDOThreadCorba" ) thread_corba = NULL;
#endif
#ifdef RDO_MT
threads_mutex.Unlock();
#endif
#ifdef TR_TRACE
trace( getName() + " INFO: " + thread->getName() + " UNREGISTERED" );
#endif
broadcastMessage( RT_THREAD_UNREGISTERED, thread );
}
// --------------------------------------------------------------------------
void Property::onInheritChange(const InheritValueChangeMsg &msg) {
// Consult the inheritor value change, and build a property change message
onPropertyModification(msg);
/* The broadcast of the property change is not done directly in the methods
above but here. The reason for this is that only the inheritor knows the
real character of the change, and the objects that the change inflicted
*/
PropertyChangeMsg pmsg;
pmsg.objectID = msg.objectID;
switch (msg.change) {
case INH_VAL_ADDED: // Property was added to an object
pmsg.change = PROP_ADDED;
break;
case INH_VAL_CHANGED: // property changed inherit value
pmsg.change = PROP_CHANGED;
break;
case INH_VAL_REMOVED: // property does not exist any more on the object (and
// not inherited)
pmsg.change = PROP_REMOVED;
break;
default:
return;
}
broadcastMessage(pmsg);
}
void GroupObject::broadcastDeltaRemove(Player* player)
{
mMembersUpdateCount++;
Message* newMessage;
gMessageFactory->StartMessage();
gMessageFactory->addUint32(0x12862153); // deltas
gMessageFactory->addUint64(mId);
gMessageFactory->addUint32(0x47525550); // GRUP
gMessageFactory->addUint8(6);
gMessageFactory->addUint32(15);
gMessageFactory->addUint16(1);
gMessageFactory->addUint16(1);
gMessageFactory->addUint32(1);
gMessageFactory->addUint32(mMembersUpdateCount);
gMessageFactory->addUint8(0);
gMessageFactory->addUint16(player->getGroupMemberIndex());
newMessage = gMessageFactory->EndMessage();
broadcastMessage(newMessage);
}
void QMetaObjectPublisher::signalEmitted(const QObject *object, const int signalIndex, const QVariantList &arguments)
{
if (!webChannel || webChannel->d_func()->transports.isEmpty()) {
if (signalIndex == s_destroyedSignalIndex)
objectDestroyed(object);
return;
}
if (!signalToPropertyMap.value(object).contains(signalIndex)) {
QJsonObject message;
const QString &objectName = registeredObjectIds.value(object);
Q_ASSERT(!objectName.isEmpty());
message[KEY_OBJECT] = objectName;
message[KEY_SIGNAL] = signalIndex;
if (!arguments.isEmpty()) {
message[KEY_ARGS] = wrapList(arguments);
}
message[KEY_TYPE] = TypeSignal;
broadcastMessage(message);
if (signalIndex == s_destroyedSignalIndex) {
objectDestroyed(object);
}
} else {
pendingPropertyUpdates[object][signalIndex] = arguments;
if (clientIsIdle && !blockUpdates && !timer.isActive()) {
timer.start(PROPERTY_UPDATE_INTERVAL, this);
}
}
}
void GameServer::handleIncomingConnections() {
if (!mListeningState) return;
if (mListenerSocket.accept(mPeers[mConnectedPlayers]->socket) == sf::TcpListener::Done) {
// order the new client to spawn its own plane ( player 1 )
mAircraftInfo[mAircraftIdentifierCounter].position = sf::Vector2f(mBattleFieldRect.width / 2, mBattleFieldRect.top + mBattleFieldRect.height / 2);
mAircraftInfo[mAircraftIdentifierCounter].hitpoints = 100;
mAircraftInfo[mAircraftIdentifierCounter].missileAmmo = 2;
sf::Packet packet;
packet << static_cast<sf::Int32>(Server::SpawnSelf);
packet << mAircraftIdentifierCounter;
packet << mAircraftInfo[mAircraftIdentifierCounter].position.x;
packet << mAircraftInfo[mAircraftIdentifierCounter].position.y;
mPeers[mConnectedPlayers]->aircraftIdentifiers.push_back(mAircraftIdentifierCounter);
broadcastMessage("New player!");
informWorldState(mPeers[mConnectedPlayers]->socket);
notifyPlayerSpawn(mAircraftIdentifierCounter++);
mPeers[mConnectedPlayers]->socket.send(packet);
mPeers[mConnectedPlayers]->ready = true;
mPeers[mConnectedPlayers]->lastPacketTime = now(); // prevent initial timeouts
mAircraftCount++;
mConnectedPlayers++;
if (mConnectedPlayers >= mMaxConnectedPlayers)
setListening(false);
else // Add a new waiting peer
mPeers.push_back(PeerPtr(new RemotePeer()));
}
}
void GroupObject::broadcastDeltaAdd(Player* player)
{
mMembersUpdateCount++;
Message* newMessage;
gMessageFactory->StartMessage();
gMessageFactory->addUint32(0x12862153); // deltas
gMessageFactory->addUint64(mId);
gMessageFactory->addUint32(0x47525550); // GRUP
gMessageFactory->addUint8(6);
gMessageFactory->addUint32(25 + (player->getName().getLength()));
gMessageFactory->addUint16(1);
gMessageFactory->addUint16(1);
gMessageFactory->addUint32(1);
gMessageFactory->addUint32(mMembersUpdateCount);
gMessageFactory->addUint8(1);
gMessageFactory->addUint16(player->getGroupMemberIndex());
gMessageFactory->addUint64(player->getCharId());
gMessageFactory->addString(player->getName());
newMessage = gMessageFactory->EndMessage();
broadcastMessage(newMessage);
}
void GroupObjectImplementation::addMember(SceneObject* newMember) {
Locker locker(_this.get());
GroupObjectDeltaMessage6* grp = new GroupObjectDeltaMessage6(_this.get());
grp->startUpdate(1);
groupMembers.add(newMember, grp);
grp->close();
broadcastMessage(grp);
if (newMember->isPlayerCreature())
{
ManagedReference<CreatureObject*> playerCreature = cast<CreatureObject*>(newMember);
sendTo(playerCreature, true);
if (hasSquadLeader()) {
addGroupModifiers(playerCreature);
}
scheduleUpdateNearestMissionForGroup(playerCreature->getPlanetCRC());
}
calcGroupLevel();
}
void GroupObjectImplementation::makeLeader(SceneObject* player) {
if (groupMembers.size() < 2 || !player->isPlayerCreature())
return;
//SceneObject* obj = groupMembers.get();
Reference<SceneObject*> temp = groupMembers.get(0).get();
for (int i = 0; i < groupMembers.size(); ++i) {
if (groupMembers.get(i) == player) {
GroupObjectDeltaMessage6* grp = new GroupObjectDeltaMessage6(_this.get());
grp->startUpdate(1);
if (hasSquadLeader())
removeGroupModifiers();
groupMembers.set(0, player, grp, 2);
groupMembers.set(i, temp.get(), grp, 0);
grp->close();
broadcastMessage(grp);
if (hasSquadLeader())
addGroupModifiers();
return;
}
}
}
void GroupObjectImplementation::removeMember(CreatureObject* member) {
bool wasLeader = getLeader() == member;
if (hasSquadLeader()) {
if (wasLeader)
removeGroupModifiers();
else
removeGroupModifiers(member);
}
for (int i = 0; i < groupMembers.size(); i++) {
CreatureObject* scno = groupMembers.get(i).get().get();
if (scno == member) {
GroupObjectDeltaMessage6* grp = new GroupObjectDeltaMessage6(_this.getReferenceUnsafeStaticCast());
grp->startUpdate(1);
groupMembers.remove(i, grp);
grp->close();
broadcastMessage(grp);
}
}
if (member->isPlayerCreature()) {
// Remove member's pets
RemovePetsFromGroupTask* task = new RemovePetsFromGroupTask(member, _this.getReferenceUnsafeStaticCast());
task->execute();
//Close any open Group SUIs.
ManagedReference<PlayerObject*> ghost = member->getPlayerObject();
if (ghost != NULL) {
ghost->closeSuiWindowType(SuiWindowType::GROUP_LOOT_RULE);
ghost->closeSuiWindowType(SuiWindowType::GROUP_LOOT_CHANGED);
ghost->closeSuiWindowType(SuiWindowType::GROUP_LOOT_PICK_LOOTER);
ghost->removeWaypointBySpecialType(WaypointObject::SPECIALTYPE_NEARESTMISSIONFORGROUP);
}
//Reset Master Looter if needed.
if (getMasterLooterID() == member->getObjectID()) {
ManagedReference<CreatureObject*> groupLeader = getLeader();
GroupManager::instance()->changeMasterLooter(_this.getReferenceUnsafeStaticCast(), groupLeader, false);
}
if (wasLeader && hasSquadLeader()) {
addGroupModifiers();
}
Zone* zone = member->getZone();
if (zone != NULL) {
scheduleUpdateNearestMissionForGroup(zone->getPlanetCRC());
}
}
updatePvPStatusNearCreature(member);
calcGroupLevel();
}
void ENetServer::broadcast(DeliveryType type, StreamBuffer::Shared stream) const
{
auto msg = Message::alloc(
++currentMsgId_, // id
MessageType::DATA,
stream);
broadcastMessage(type, msg);
}
void ComponentManager::broadcastMessage(const MessageBase& msg) {
unsigned int mid_index = msg.m_MID;
for (int i = 0; i < MAX_INTERFACES; i++)
if (m_subscriptions[i + MAX_INTERFACES * mid_index]) {
InterfaceTypeID iid = i;
broadcastMessage(iid, msg);
}
}
void GroupObject::broadcastDeltaResetAll()
{
mMembersUpdateCount++;
Message* baselineBody;
gMessageFactory->StartMessage();
// two updates : reset all & set master looter to the new leaders'id
gMessageFactory->addUint16(2);
gMessageFactory->addUint16(1);
gMessageFactory->addUint32(1);
gMessageFactory->addUint32(mMembersUpdateCount);
gMessageFactory->addUint8(3); //reset all
gMessageFactory->addUint16((uint16)mMembers.size());
PlayerList::iterator listIt;
Player* runningPlayer;
listIt = mMembers.begin();
while(listIt != mMembers.end())
{
runningPlayer = (Player*)(*listIt);
gMessageFactory->addUint64(runningPlayer->getCharId());
gMessageFactory->addString(runningPlayer->getName());
++listIt;
}
// modify part 6 (master looter id)
gMessageFactory->addUint16(6);
gMessageFactory->addUint64(mMasterLooter);
baselineBody = gMessageFactory->EndMessage();
Message* newMessage;
gMessageFactory->StartMessage();
gMessageFactory->addUint32(0x12862153); // deltas
gMessageFactory->addUint64(mId);
gMessageFactory->addUint32(0x47525550); // GRUP
gMessageFactory->addUint8(6);
gMessageFactory->addUint32(baselineBody->getSize());
gMessageFactory->addData(baselineBody ->getData(), baselineBody->getSize());
newMessage = gMessageFactory->EndMessage();
gMessageFactory->DestroyMessage(baselineBody);
// update counter need to match the amount of modifications we did here
mMembersUpdateCount += mMembers.size();
broadcastMessage(newMessage);
}
void RDOKernelGUI::unregistered( RDOThread* thread )
{
if ( thread && std::find( threads.begin(), threads.end(), thread ) != threads.end() ) {
threads.remove( thread );
update_notifies();
#ifdef TR_TRACE
trace( getName() + " INFO: " + thread->getName() + " UNREGISTERED" );
#endif
broadcastMessage( RT_THREAD_UNREGISTERED, thread );
}
}
// --------------------------------------------------------------------------
void Property::clear() {
PropertyChangeMsg msg;
msg.change = PROP_CLEARED;
msg.objectID = 0;
broadcastMessage(msg);
mPropertyStorage->clear();
mInheritor->clear();
}
void ServerThreaded::processNewConnection()
{
Log::display("Client connected");
// Get the connecting socket
QWsSocket * socket = server->nextPendingConnection();
// Create a new thread and giving to him the socket
SocketThread * thread = new SocketThread( socket );
// connect for message broadcast
connect( socket, SIGNAL(frameReceived(QString)), this, SIGNAL(broadcastMessage(QString)) );
connect( this, SIGNAL(broadcastMessage(QString)), thread, SLOT(sendMessage(QString)) );
// connect for message display in log
connect( socket, SIGNAL(frameReceived(QString)), this, SLOT(displayMessage(QString)) );
// Starting the thread
thread->start();
}
void RDOKernelGUI::registration( RDOThread* thread )
{
if ( thread && thread->thread_id == thread_id && std::find( threads.begin(), threads.end(), thread ) == threads.end() ) {
threads.push_back( thread );
update_notifies();
#ifdef TR_TRACE
trace( getName() + " INFO: " + thread->getName() + " REGISTERED" );
#endif
broadcastMessage( RT_THREAD_REGISTERED, thread );
}
}
void TangibleObjectImplementation::setCustomObjectName(const UnicodeString& name, bool notifyClient) {
customName = name;
if (!notifyClient)
return;
TangibleObjectDeltaMessage3* dtano3 = new TangibleObjectDeltaMessage3(asTangibleObject());
dtano3->updateName(name);
dtano3->close();
broadcastMessage(dtano3, true);
}
void TangibleObjectImplementation::setObjectName(StringId& stringID, bool notifyClient) {
objectName = stringID;
if (!notifyClient)
return;
TangibleObjectDeltaMessage3* dtano3 = new TangibleObjectDeltaMessage3(asTangibleObject());
dtano3->updateObjectName(stringID);
dtano3->close();
broadcastMessage(dtano3, true);
}
void IntangibleObjectImplementation::setCustomObjectName(const UnicodeString& name, bool notifyClient) {
customName = name;
if (!notifyClient)
return;
IntangibleObjectDeltaMessage3* ditno3 = new IntangibleObjectDeltaMessage3(_this.getReferenceUnsafeStaticCast());
ditno3->updateName(name);
ditno3->close();
broadcastMessage(ditno3, true);
}
void TangibleObjectImplementation::setCustomizationVariable(byte type, int16 value, bool notifyClient) {
customizationVariables.setVariable(type, value);
if (!notifyClient)
return;
TangibleObjectDeltaMessage3* dtano3 = new TangibleObjectDeltaMessage3(asTangibleObject());
dtano3->updateCustomizationString();
dtano3->close();
broadcastMessage(dtano3, true);
}
bool Party::leave(Player* player)
{
if(!player)
return false;
if(!isPlayerMember(player) && getLeader() != player)
return false;
bool missingLeader = false;
if(getLeader() == player)
{
if(!memberList.empty())
{
if(memberList.size() == 1 && inviteList.empty())
missingLeader = true;
else
passLeadership(memberList.front());
}
else
missingLeader = 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->sendClosePrivate(CHANNEL_PARTY);
player->sendTextMessage(MSG_INFO_DESCR, "You have left the party.");
player->sendPlayerPartyIcons(player);
updateSharedExperience();
updateIcons(player);
clearPlayerPoints(player);
char buffer[105];
sprintf(buffer, "%s has left the party.", player->getName().c_str());
broadcastMessage(MSG_INFO_DESCR, buffer);
if(missingLeader || canDisband())
disband();
return true;
}
