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