C++ BString::getLength方法代码示例

BString ObjectController::handleCancelShutdownGalaxy(BString message) const
{
    int8 replyData[128];

    if (!AdminManager::Instance()->shutdownPending())
    {
        sprintf(replyData,"No shutdown in progress");
    }
    else
    {
        sprintf(replyData,"OK");

        // We have no idea of how much white space are inserted in string...
        BString ansiData;
        int32 index = indexOfFirstField(message);
        if (index < 0)
        {
            // We may not have any "next field", it's optional here.
            index = 0;
            ansiData = "";
        }
        else
        {
            // Now we can get the broadcaste from the message.
            // Remove first field from message.
            ansiData.setLength(message.getLength());
            message.substring(ansiData, static_cast<uint16>(index), message.getLength());
        }

        // Send request to all zones, via chatserver.
        this->cancelScheduledShutdown(ansiData);
    }
    return replyData;
}

BString ObjectController::handleBroadcastGalaxy(BString message) const
{
    int8* replyStr = "OK";

    int8 rawData[128];
    // We have no idea of how much white space are inserted in string...
    int32 index = indexOfFirstField(message);
    if (index >= 0)
    {
        // Now we can get the broadcast from the message.

        // Remove white space from start of message.
        BString ansiData;
        ansiData.setLength(message.getLength());
        message.substring(ansiData, static_cast<uint16>(index), message.getLength());

        // Any valid message?
        int32 elementCount = sscanf(ansiData.getAnsi(), "%80s", rawData);
        if (elementCount > 0)
        {
            this->broadcastGalaxyMessage(ansiData, -1);
        }
        else
        {
            replyStr = "No broadcast supplied";
        }
    }
    else
    {
        replyStr = "No valid broadcast supplied";
    }
    return replyStr;
}

void ChatMessageLib::sendChatRoomList(DispatchClient* client, ChannelList* list) const
{
    ChannelList::iterator iter = list->begin();

    gMessageFactory->StartMessage();
    gMessageFactory->addUint32(opChatRoomlist);

    gMessageFactory->addUint32(list->size());
    while (iter != list->end())
    {
        gMessageFactory->addUint32((*iter)->getId());
        gMessageFactory->addUint32((uint32)(*iter)->isPrivate());
        gMessageFactory->addUint8((*iter)->isModerated());

        BString roomPathName = "SWG.";
        roomPathName << (*iter)->getGalaxy().getAnsi() << ".";
        roomPathName << (*iter)->getName().getAnsi();
        gMessageFactory->addString(roomPathName);

        gMessageFactory->addString(SWG);
        gMessageFactory->addString((*iter)->getGalaxy());
#ifdef DISP_REAL_FIRST_NAME
        BString* name = (ChatManager::getSingletonPtr()->getFirstName((BString &)((*iter)->getOwner()->getLoweredName())));
        if (name->getLength() == 0)
        {
            gMessageFactory->addString((*iter)->getOwner()->getLoweredName());
        }
        else
        {
            gMessageFactory->addString(*name);
        }
#else
        gMessageFactory->addString((*iter)->getOwner()->getLoweredName());
#endif

        gMessageFactory->addString(SWG);
        gMessageFactory->addString((*iter)->getGalaxy());
#ifdef DISP_REAL_FIRST_NAME
        name = (ChatManager::getSingletonPtr()->getFirstName((BString &)((*iter)->getCreator()->getLoweredName())));
        if (name->getLength() == 0)
        {
            gMessageFactory->addString((*iter)->getCreator()->getLoweredName());
        }
        else
        {
            gMessageFactory->addString(*name);
        }
#else
        gMessageFactory->addString((*iter)->getCreator()->getLoweredName());
#endif
        gMessageFactory->addString((*iter)->getTitle());

        gMessageFactory->addUint32(0);
        gMessageFactory->addUint32(0);
        ++iter;
    }
    Message* message = gMessageFactory->EndMessage();

    client->SendChannelA(message, client->getAccountId(), CR_Client, 2);
}

void ObjectController::_handleSetWaypointName(uint64 targetId,Message* message,ObjectControllerCmdProperties* cmdProperties)
{
    PlayerObject*	player		= dynamic_cast<PlayerObject*>(mObject);
    BString			name;
    Datapad* datapad			= player->getDataPad();
    WaypointObject*	waypoint	= datapad->getWaypointById(targetId);
    int8			sql[1024],restStr[64],*sqlPointer;

    if(waypoint == NULL)
    {
        DLOG(info) << "ObjController::handlesetwaypointname: could not find waypoint "<< targetId;
        return;
    }

    message->getStringUnicode16(name);

    if(!(name.getLength()))
        return;

    waypoint->setName(name);

    name.convert(BSTRType_ANSI);

    sprintf(sql,"UPDATE %s.waypoints SET name='",mDatabase->galaxy());
    sqlPointer = sql + strlen(sql);
    sqlPointer += mDatabase->escapeString(sqlPointer,name.getAnsi(),name.getLength());
    sprintf(restStr,"' WHERE waypoint_id=%" PRIu64 "",targetId);
    strcat(sql,restStr);

    mDatabase->executeSqlAsync(NULL,NULL,sql);


    gMessageLib->sendUpdateWaypoint(waypoint,ObjectUpdateChange,player);
}

void ChatMessageLib::sendGroupSystemMessage(BString name, BString pointer, Player* target, GroupObject* group, bool unicode) const
{
    name.convert(BSTRType_Unicode16);
    uint32	pointerLength = (uint32)ceil((double)(pointer.getLength() / 2));

    Message* newMessage;

    gMessageFactory->StartMessage();
    gMessageFactory->addUint32(opChatSystemMessage);
    gMessageFactory->addUint8(0);
    gMessageFactory->addUint32(0);

    gMessageFactory->addUint32(45 + pointerLength + name.getLength());
    gMessageFactory->addUint16(1);
    gMessageFactory->addUint8(1);
    gMessageFactory->addUint32(0xffffffff);
    gMessageFactory->addString(BString("group"));
    gMessageFactory->addUint32(0);
    gMessageFactory->addString(pointer);
    gMessageFactory->addUint64(0);
    gMessageFactory->addUint64(0);

    if(unicode)
    {
        gMessageFactory->addString(name);
        gMessageFactory->addUint32(0);
        gMessageFactory->addUint64(0);
        gMessageFactory->addUint32(0);
        gMessageFactory->addUint32(0);
    }
    else
    {
        gMessageFactory->addUint32(0);
        gMessageFactory->addUint32(0);
        gMessageFactory->addUint64(0);
        gMessageFactory->addUint32(0);
        gMessageFactory->addString(name);
    }

    gMessageFactory->addUint64(0);
    gMessageFactory->addUint64(0);
    gMessageFactory->addUint32(0);
    gMessageFactory->addUint32(0);
    gMessageFactory->addUint32(0);
    gMessageFactory->addUint16(0);

    newMessage = gMessageFactory->EndMessage();

    if(group == NULL)
    {
        target->getClient()->SendChannelA(newMessage, target->getClient()->getAccountId(), CR_Client, 5);
    }
    else
    {
        group->broadcastMessage(newMessage);
    }
}

BString ObjectController::handleShutdownGalaxy(BString message) const
{
    int8 replyData[128];

    if (AdminManager::Instance()->shutdownPending())
    {
        sprintf(replyData,"Shutdown already in progress");
    }
    else
    {
        sprintf(replyData,"OK");
        // Get time for shutdown
        //
        int32 minutesToShutdown;
        int32 elementCount = sscanf(message.getAnsi(), "%3d", &minutesToShutdown);
        // string planet(rawData);
        if (elementCount > 0)
        {
            // We have no idea of how much white space are inserted in string...
            BString ansiData;
            int32 index = indexOfNextField(message);
            if (index < 0)
            {
                // We may not have any "next field", it's optional here.
                index = 0;
                ansiData = "";
            }
            else
            {
                // Now we can get the broadcaste from the message.
                // Remove first field from message.
                ansiData.setLength(message.getLength());
                message.substring(ansiData, static_cast<uint16>(index), message.getLength());
            }

            // Validate the timeout.
            if (minutesToShutdown >= 0)
            {
                // Any valid message?
                int8 rawData[128];
                elementCount = sscanf(ansiData.getAnsi(), "%80s", rawData);
                // Send request to all zones, via chatserver.
                this->scheduleShutdown(minutesToShutdown*60, ansiData);
            }
            else
            {
                sprintf(replyData,"%d is not valid shutdown time", minutesToShutdown);
            }
        }
        else
        {
            sprintf(replyData,"No shutdown time supplied");
        }
    }
    return replyData;
}

BString ObjectController::handleBroadcastPlanet(BString message) const
{
    // Get planet name
    int8 rawData[128];
    rawData[0] = 0;

    int32 elementCount = sscanf(message.getAnsi(), "%80s", rawData);
    BString planet(rawData);
    if (elementCount > 0)
    {
        // Yes. Validate the planet name.
        int32 planetId = gWorldManager->getPlanetIdByNameLike(planet);
        if (planetId >= 0)
        {
            // We have no idea of how much white space are inserted in string...
            int32 index = indexOfNextField(message);
            if (index > 0)
            {
                // Now we can get the broadcaste from the message.
                // Remove planet name from message.
                BString ansiData;
                ansiData.setLength(message.getLength());
                message.substring(ansiData, static_cast<uint16>(index), message.getLength());

                // Any valid message?
                elementCount = sscanf(ansiData.getAnsi(), "%80s", rawData);
                if (elementCount > 0)
                {
                    // string planetName(gWorldManager->getPlanetNameById(planetId));

                    this->broadcastGalaxyMessage(ansiData, planetId);
                    sprintf(rawData,"OK");
                }
                else
                {
                    sprintf(rawData,"No broadcast supplied");
                }
            }
            else
            {
                sprintf(rawData,"No valid broadcast supplied");
            }
        }
        else
        {
            sprintf(rawData,"%s is not valid planet name", planet.getAnsi());
        }
    }
    else
    {
        sprintf(rawData,"Missing planet name");
    }
    return rawData;
}

BString ObjectController::removeWhiteSpace(BString str) const
{
    int32 index = indexOfFirstField(str);
    if (index > 0)
    {
        // Remove white space from start of message.
        BString resultStr;
        resultStr.setLength(str.getLength());
        str.substring(resultStr, static_cast<uint16>(index), str.getLength());
        return resultStr;
    }
    // Nothing we can do about that string... good or bad.
    return str;
}

void ChatMessageLib::sendChatOnCreateRoom(DispatchClient* client, Channel* channel, uint32 requestId) const
{
    gMessageFactory->StartMessage();
    gMessageFactory->addUint32(opChatOnCreateRoom);

    gMessageFactory->addUint32(0);
    gMessageFactory->addUint32(channel->getId());
    gMessageFactory->addUint32((uint32)channel->isPrivate());
    gMessageFactory->addUint8(channel->isModerated());
    gMessageFactory->addString(channel->getFullPath());

    gMessageFactory->addString(SWG);
    gMessageFactory->addString(channel->getGalaxy());
#ifdef DISP_REAL_FIRST_NAME
    BString* name = (ChatManager::getSingletonPtr()->getFirstName((BString &)(channel->getOwner()->getLoweredName())));
    if (name->getLength() == 0)
    {
        gMessageFactory->addString(channel->getOwner()->getLoweredName());
    }
    else
    {
        gMessageFactory->addString(*name);
    }
#else
    gMessageFactory->addString(channel->getOwner()->getLoweredName());
#endif
    gMessageFactory->addString(SWG);
    gMessageFactory->addString(channel->getGalaxy());
#ifdef DISP_REAL_FIRST_NAME
    name = (ChatManager::getSingletonPtr()->getFirstName((BString &)(channel->getCreator()->getLoweredName())));
    if (name->getLength() == 0)
    {
        gMessageFactory->addString(channel->getCreator()->getLoweredName());
    }
    else
    {
        gMessageFactory->addString(*name);
    }
#else
    gMessageFactory->addString(channel->getCreator()->getLoweredName());
#endif
    gMessageFactory->addString(channel->getTitle());
    gMessageFactory->addUint32(0);
    gMessageFactory->addUint32(0);
    gMessageFactory->addUint32(requestId);
    Message* message = gMessageFactory->EndMessage();

    client->SendChannelA(message, client->getAccountId(), CR_Client, 4);
}

BString ObjectController::skipToNextField(BString str) const
{
    int32 index = indexOfNextField(str);
    if (index < 0)
    {
        // Not all commands have payload.
        index = str.getLength();
    }

    // Remove white space from start of message.
    BString resultStr;
    resultStr.setLength(str.getLength());
    str.substring(resultStr, static_cast<uint16>(index), str.getLength());
    return resultStr;
}

BString ObjectController::handleBroadcast(BString message) const
{
    int8 rawData[128];

    int8* replyStr = "OK";
    if (message.getLength())
    {
        // Any valid message?
        int32 elementCount = sscanf(message.getAnsi(), "%80s", rawData);
        if (elementCount > 0)
        {
            message.convert(BSTRType_Unicode16);

            PlayerAccMap::const_iterator it = gWorldManager->getPlayerAccMap()->begin();
            while(it != gWorldManager->getPlayerAccMap()->end())
            {
                const PlayerObject* const player = (*it).second;
                if (player->isConnected())
                {
                    gMessageLib->SendSystemMessage(message.getUnicode16(), player);
                }
                ++it;
            }
        }
        else
        {
            replyStr = "No broadcast supplied";
        }
    }
    else
    {
        replyStr = "No broadcast supplied";
    }
    return replyStr;
}

bool MessageLib::sendXpUpdate(uint32 xpType,PlayerObject* playerObject)
{
    if(!(playerObject->isConnected()))
        return(false);

    // We must be able to set the value of 0, when we use up all xp.

    BString		xpTypeName = gSkillManager->getXPTypeById(xpType);

    mMessageFactory->StartMessage();
    mMessageFactory->addUint32(opDeltasMessage);
    mMessageFactory->addUint64(playerObject->getId());
    mMessageFactory->addUint32(opPLAY);
    mMessageFactory->addUint8(8);

    mMessageFactory->addUint32(19 + xpTypeName.getLength());

    mMessageFactory->addUint16(1);
    mMessageFactory->addUint16(0);

    mMessageFactory->addUint32(1);
    mMessageFactory->addUint32(++playerObject->mXpUpdateCounter);

    mMessageFactory->addUint8(2);
    mMessageFactory->addString(xpTypeName);
    mMessageFactory->addInt32(playerObject->getXpAmount(xpType));

    (playerObject->getClient())->SendChannelA(mMessageFactory->EndMessage(),playerObject->getAccountId(),CR_Client,5);

    return(true);
}

void ObjectController::sendAdminFeedback(BString reply) const
{
    PlayerObject* player = dynamic_cast<PlayerObject*>(mObject);
    if ((player) && (player->isConnected()))
    {
        if (reply.getLength())
        {
            reply.convert(BSTRType_Unicode16);
            gMessageLib->SendSystemMessage(reply.getUnicode16(), player, true);
        }
        else
        {
            DLOG(info) << "Admin :" << player->getFirstName().getAnsi();
        }
    }
    else
    {
        if (reply.getDataLength())
        {
            DLOG(info) << "Admin (anon): " << reply.getAnsi();
        }
        else
        {
        }
    }
}

void ObjectController::broadcastGalaxyMessage(BString theBroadcast, int32 planetId) const
{
    if (theBroadcast.getLength())
    {
        PlayerObject* player = dynamic_cast<PlayerObject*>(mObject);
        if (player)
        {
            theBroadcast.convert(BSTRType_Unicode16);

            // let the chatserver handle this.
            Message* newMessage;
            gMessageFactory->StartMessage();
            gMessageFactory->addUint32(opIsmBroadcastGalaxy);
            gMessageFactory->addUint32(planetId);
            gMessageFactory->addString(theBroadcast);
            newMessage = gMessageFactory->EndMessage();
            player->getClient()->SendChannelA(newMessage,player->getAccountId(),CR_Chat,2);
            //this should be fastpath as not being Mission critical and we want to prevent the communication protocol overhead with Acks and resends

            // Convert since we are going to print it.
            // theBroadcast.convert(BSTRType_ANSI);
        }
    }

}

void ObjectController::sendAdminFeedback(BString reply) const
{
    PlayerObject* player = dynamic_cast<PlayerObject*>(mObject);
    if ((player) && (player->isConnected()))
    {
        if (reply.getLength())
        {
            gLogger->log(LogManager::NOTICE,"Admin (%s): %s", player->getFirstName().getAnsi(), reply.getAnsi());
            reply.convert(BSTRType_Unicode16);
            gMessageLib->SendSystemMessage(reply.getUnicode16(), player, true);
        }
        else
        {
            gLogger->log(LogManager::NOTICE,"Admin (%s):", player->getFirstName().getAnsi());
        }
    }
    else
    {
        if (reply.getDataLength())
        {
            gLogger->log(LogManager::NOTICE,"Admin (anon): %s", reply.getAnsi());
        }
        else
        {
            gLogger->log(LogManager::NOTICE,"Admin (anon):");
        }
    }
}