Ea::BeingRecv Namespace Reference

Functions
void	processBeingRemove (Net::MessageIn &msg)
void	processBeingAction (Net::MessageIn &msg)
void	processBeingEmotion (Net::MessageIn &msg)
void	processNameResponse (Net::MessageIn &msg)
void	processPlayerStop (Net::MessageIn &msg)
void	processPlayerMoveToAttack (Net::MessageIn &msg)
void	processSkillNoDamage (Net::MessageIn &msg)
void	processPvpMapMode (Net::MessageIn &msg)
void	processBeingMove3 (Net::MessageIn &msg)
Being *	createBeing (const BeingId id, const int job)

Variables
BeingId	mSpawnId = BeingId_zero
bool	mSync

Function Documentation

createBeing()

Being * Ea::BeingRecv::createBeing	(	const BeingId	id,
		const int	job
	)

Definition at line 507 of file beingrecv.cpp.

{
    if (actorManager == nullptr)
        return nullptr;
 
    ActorTypeT type = ActorType::Unknown;
    if (job <= 25 || (job >= 4001 && job <= 4049))
        type = ActorType::Player;
    else if (job >= 46 && job <= 1000)
        type = ActorType::Npc;
    else if (job > 1000 && job <= 2000)
        type = ActorType::Monster;
    else if (job == 45)
        type = ActorType::Portal;
 
    return actorManager->createBeing(
        id, type, fromInt(job, BeingTypeId));
}

References actorManager, ActorManager::createBeing(), fromInt, ActorType::Monster, ActorType::Npc, ActorType::Player, ActorType::Portal, and ActorType::Unknown.

Referenced by TmwAthena::BeingRecv::processBeingMove(), TmwAthena::BeingRecv::processBeingVisible(), TmwAthena::BeingRecv::processPlayerMove(), TmwAthena::BeingRecv::processPlayerUpdate1(), and TmwAthena::BeingRecv::processPlayerUpdate2().

processBeingAction()

void Ea::BeingRecv::processBeingAction

(

Net::MessageIn &

msg

)

Definition at line 149 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processBeingAction")
    if (actorManager == nullptr)
    {
        BLOCK_END("BeingRecv::processBeingAction")
        return;
    }
 
    Being *const srcBeing = actorManager->findBeing(
        msg.readBeingId("src being id"));
    Being *const dstBeing = actorManager->findBeing(
        msg.readBeingId("dst being id"));
 
    msg.readInt32("tick");
    const int srcSpeed = msg.readInt32("src speed");
    msg.readInt32("dst speed");
    const int param1 = msg.readInt16("param1");
    msg.readInt16("param 2");
    const AttackTypeT type = static_cast<AttackTypeT>(
        msg.readUInt8("type"));
    msg.readInt16("param 3");
 
    switch (type)
    {
        case AttackType::HIT:  // Damage
        case AttackType::CRITICAL:  // Critical Damage
        case AttackType::MULTI:  // Critical Damage
        case AttackType::REFLECT:  // Reflected Damage
        case AttackType::FLEE:  // Lucky Dodge
            if (srcBeing != nullptr)
            {
                if (srcSpeed != 0 && srcBeing->getType() == ActorType::Player)
                    srcBeing->setAttackDelay(srcSpeed);
                // attackid=1, type
                srcBeing->handleAttack(dstBeing, param1, 1);
                if (srcBeing->getType() == ActorType::Player)
                    srcBeing->setAttackTime();
            }
            if (dstBeing != nullptr)
            {
                // level not present, using 1
                dstBeing->takeDamage(srcBeing, param1,
                    static_cast<AttackTypeT>(type), 1, 1);
            }
            break;
 
        case AttackType::PICKUP:
            break;
            // tmw server can send here garbage?
//            if (srcBeing)
//                srcBeing->setAction(BeingAction::DEAD, 0);
 
        case AttackType::SIT:
            if (srcBeing != nullptr)
            {
                srcBeing->setAction(BeingAction::SIT, 0);
                if (srcBeing->getType() == ActorType::Player)
                {
                    srcBeing->setMoveTime();
                    if (localPlayer != nullptr)
                        localPlayer->imitateAction(srcBeing, BeingAction::SIT);
                }
            }
            break;
 
        case AttackType::STAND:
            if (srcBeing != nullptr)
            {
                srcBeing->setAction(BeingAction::STAND, 0);
                if (srcBeing->getType() == ActorType::Player)
                {
                    srcBeing->setMoveTime();
                    if (localPlayer != nullptr)
                    {
                        localPlayer->imitateAction(srcBeing,
                            BeingAction::STAND);
                    }
                }
            }
            break;
        default:
        case AttackType::SPLASH:
        case AttackType::SKILL:
        case AttackType::REPEATE:
        case AttackType::MULTI_REFLECT:
        case AttackType::TOUCH_SKILL:
        case AttackType::MISS:
        case AttackType::SKILLMISS:
            UNIMPLEMENTEDPACKETFIELD(CAST_S32(type));
            break;
    }
    BLOCK_END("BeingRecv::processBeingAction")
}

References actorManager, BLOCK_END, BLOCK_START, CAST_S32, AttackType::CRITICAL, ActorManager::findBeing(), AttackType::FLEE, Being::getType(), Being::handleAttack(), AttackType::HIT, LocalPlayer::imitateAction(), localPlayer, AttackType::MISS, Actions::msg(), AttackType::MULTI, AttackType::MULTI_REFLECT, AttackType::PICKUP, ActorType::Player, AttackType::REFLECT, AttackType::REPEATE, Being::setAction(), Being::setAttackDelay(), Being::setAttackTime(), Being::setMoveTime(), AttackType::SIT, BeingAction::SIT, AttackType::SKILL, AttackType::SKILLMISS, AttackType::SPLASH, AttackType::STAND, BeingAction::STAND, Being::takeDamage(), AttackType::TOUCH_SKILL, and UNIMPLEMENTEDPACKETFIELD.

processBeingEmotion()

void Ea::BeingRecv::processBeingEmotion

(

Net::MessageIn &

msg

)

Definition at line 244 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processBeingEmotion")
    if ((localPlayer == nullptr) || (actorManager == nullptr))
    {
        BLOCK_END("BeingRecv::processBeingEmotion")
        return;
    }
 
    Being *const dstBeing = actorManager->findBeing(
        msg.readBeingId("being id"));
    if (dstBeing == nullptr)
    {
        DEBUGLOGSTR("invisible player?");
        msg.readUInt8("emote");
        BLOCK_END("BeingRecv::processBeingEmotion")
        return;
    }
 
    const uint8_t emote = msg.readUInt8("emote");
    if ((emote != 0U) &&
        playerRelations.hasPermission(dstBeing, PlayerRelation::EMOTE))
    {
        dstBeing->setEmote(emote, 0);
        localPlayer->imitateEmote(dstBeing, emote);
    }
    if (dstBeing->getType() == ActorType::Player)
        dstBeing->setOtherTime();
    BLOCK_END("BeingRecv::processBeingEmotion")
}

References actorManager, BLOCK_END, BLOCK_START, DEBUGLOGSTR, PlayerRelation::EMOTE, Actions::emote(), ActorManager::findBeing(), Being::getType(), PlayerRelationsManager::hasPermission(), LocalPlayer::imitateEmote(), localPlayer, Actions::msg(), ActorType::Player, playerRelations, Being::setEmote(), and Being::setOtherTime().

processBeingMove3()

void Ea::BeingRecv::processBeingMove3

(

Net::MessageIn &

msg

)

Definition at line 418 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processBeingMove3")
    if ((actorManager == nullptr) || !serverFeatures->haveMove3())
    {
        BLOCK_END("BeingRecv::processBeingMove3")
        return;
    }
 
    static const int16_t dirx[8] = {0, -1, -1, -1,  0,  1, 1, 1};
    static const int16_t diry[8] = {1,  1,  0, -1, -1, -1, 0, 1};
 
    const int len = msg.readInt16("len") - 14;
    Being *const dstBeing = actorManager->findBeing(
        msg.readBeingId("being id"));
    if (dstBeing == nullptr ||
        dstBeing == localPlayer)
    {
        DEBUGLOGSTR("invisible player?");
        msg.readInt16("speed");
        msg.readInt16("x");
        msg.readInt16("y");
        unsigned char *bytes = msg.readBytes(len, "moving path");
        delete [] bytes;
        BLOCK_END("BeingRecv::processBeingMove3")
        return;
    }
    const int16_t speed = msg.readInt16("speed");
    dstBeing->setWalkSpeed(speed);
    const int16_t x = msg.readInt16("x");
    const int16_t y = msg.readInt16("y");
    const unsigned char *moves = msg.readBytes(len, "moving path");
 
    Path path;
    if (moves != nullptr)
    {
        int x2 = dstBeing->getCachedX();
        int y2 = dstBeing->getCachedY();
        Path path2;
        path2.push_back(Position(x2, y2));
        for (int f = len - 1; f >= 0; f --)
        {
            const unsigned char dir = moves[f];
            if (dir <= 7)
            {
                x2 -= dirx[dir];
                y2 -= diry[dir];
                // fix possible wrong move outside of map
                if (x2 < 0)
                    x2 = 0;
                if (y2 < 0)
                    y2 = 0;
                path2.push_back(Position(x2, y2));
                if (x2 == x && y2 == y)
                    break;
            }
            else
            {
                logger->log("bad move packet: %d", dir);
            }
        }
 
        if (!path2.empty())
        {
            const Position &pos = path2.back();
            if (x != pos.x ||
                y != pos.y)
            {
                dstBeing->setTileCoords(pos.x, pos.y);
            }
        }
 
        path2.pop_back();
        FOR_EACHR (PathRIterator, it, path2)
        {
            path.push_back(*it);
        }
        delete [] moves;
    }
 
    if (path.empty())
        return;
 
    dstBeing->setAction(BeingAction::STAND, 0);
    dstBeing->setTileCoords(x, y);
    dstBeing->setPath(path);
    BLOCK_END("BeingRecv::processBeingMove3")
}

References actorManager, BLOCK_END, BLOCK_START, DEBUGLOGSTR, ActorManager::findBeing(), FOR_EACHR, Being::getCachedX(), Being::getCachedY(), Net::ServerFeatures::haveMove3(), localPlayer, Logger::log(), logger, Actions::msg(), CastType::Position, serverFeatures, Being::setAction(), Being::setPath(), Being::setTileCoords(), Being::setWalkSpeed(), BeingAction::STAND, Position::x, x, Position::y, and y.

processBeingRemove()

void Ea::BeingRecv::processBeingRemove

(

Net::MessageIn &

msg

)

Definition at line 61 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processBeingRemove")
    if ((actorManager == nullptr) || (localPlayer == nullptr))
    {
        BLOCK_END("BeingRecv::processBeingRemove")
        return;
    }
 
    // A being should be removed or has died
 
    const BeingId id = msg.readBeingId("being id");
    const uint8_t type = msg.readUInt8("remove flag");
    Being *const dstBeing = actorManager->findBeing(id);
    if (dstBeing == nullptr)
    {
        BLOCK_END("BeingRecv::processBeingRemove")
        return;
    }
 
    localPlayer->followMoveTo(dstBeing, localPlayer->getNextDestX(),
        localPlayer->getNextDestY());
 
    // If this is player's current target, clear it.
    if (dstBeing == localPlayer->getTarget())
        localPlayer->stopAttack(true);
 
    if (type == 1U)
    {
        if (dstBeing->getCurrentAction() != BeingAction::DEAD)
        {
            dstBeing->setAction(BeingAction::DEAD, 0);
            dstBeing->recalcSpritesOrder();
        }
    }
    else if (type == 0U && dstBeing->getType() == ActorType::Npc)
    {
        const BeingInfo *const info = dstBeing->getInfo();
        if ((info == nullptr) || (info->getAllowDelete() != 0))
            actorManager->destroy(dstBeing);
    }
    else
    {
        if (dstBeing->getType() == ActorType::Player)
        {
            if (socialWindow != nullptr)
                socialWindow->updateActiveList();
            const std::string name = dstBeing->getName();
            if (!name.empty() && config.getBoolValue("logPlayerActions"))
            {
                switch (type)
                {
                    case 0:
                        dstBeing->serverRemove();
                        break;
                    case 1:
                        NotifyManager::notify(
                            NotifyTypes::BEING_REMOVE_DIED,
                            name);
                        break;
                    case 2:
                        NotifyManager::notify(
                            NotifyTypes::BEING_REMOVE_LOGGED_OUT,
                            name);
                        break;
                    case 3:
                        NotifyManager::notify(
                            NotifyTypes::BEING_REMOVE_WARPED,
                            name);
                        break;
                    case 4:
                        NotifyManager::notify(
                            NotifyTypes::BEING_REMOVE_TRICK_DEAD,
                            name);
                        break;
                    default:
                        NotifyManager::notify(
                            NotifyTypes::BEING_REMOVE_UNKNOWN,
                            name);
                        break;
                }
            }
        }
        actorManager->destroy(dstBeing);
    }
    BLOCK_END("BeingRecv::processBeingRemove")
}

References actorManager, NotifyTypes::BEING_REMOVE_DIED, NotifyTypes::BEING_REMOVE_LOGGED_OUT, NotifyTypes::BEING_REMOVE_TRICK_DEAD, NotifyTypes::BEING_REMOVE_UNKNOWN, NotifyTypes::BEING_REMOVE_WARPED, BLOCK_END, BLOCK_START, config, BeingAction::DEAD, ActorManager::destroy(), ActorManager::findBeing(), LocalPlayer::followMoveTo(), Configuration::getBoolValue(), Being::getCurrentAction(), Being::getInfo(), Being::getName(), LocalPlayer::getNextDestX(), LocalPlayer::getNextDestY(), LocalPlayer::getTarget(), Being::getType(), Actions::info(), localPlayer, Actions::msg(), NotifyManager::notify(), ActorType::Npc, ActorType::Player, Being::recalcSpritesOrder(), Being::serverRemove(), Being::setAction(), socialWindow, LocalPlayer::stopAttack(), and SocialWindow::updateActiveList().

processNameResponse()

void Ea::BeingRecv::processNameResponse

(

Net::MessageIn &

msg

)

Definition at line 275 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processNameResponse")
    if ((localPlayer == nullptr) || (actorManager == nullptr))
    {
        BLOCK_END("BeingRecv::processNameResponse")
        return;
    }
 
    const BeingId beingId = msg.readBeingId("being id");
    const std::string name = msg.readString(24, "name");
    Being *const dstBeing = actorManager->findBeing(beingId);
 
    actorManager->updateNameId(name, beingId);
 
    if (dstBeing != nullptr)
    {
        if (beingId == localPlayer->getId())
        {
            localPlayer->pingResponse();
        }
        else
        {
            if (dstBeing->getType() != ActorType::Portal)
            {
                dstBeing->setName(name);
            }
            else if (viewport != nullptr)
            {
                Map *const map = viewport->getMap();
                if (map != nullptr)
                {
                    map->addPortalTile(name, MapItemType::PORTAL,
                        dstBeing->getTileX(), dstBeing->getTileY());
                }
            }
            dstBeing->updateGuild();
            dstBeing->addToCache();
 
            if (dstBeing->getType() == ActorType::Player)
                dstBeing->updateColors();
 
            if (localPlayer != nullptr)
            {
                const Party *const party = localPlayer->getParty();
                if (party != nullptr && party->isMember(dstBeing->getId()))
                {
                    PartyMember *const member = party->getMember(
                        dstBeing->getId());
 
                    if (member != nullptr)
                        member->setName(dstBeing->getName());
                }
                localPlayer->checkNewName(dstBeing);
            }
            BLOCK_END("BeingRecv::processNameResponse")
            return;
        }
    }
    BLOCK_END("BeingRecv::processNameResponse")
}

References actorManager, Map::addPortalTile(), Being::addToCache(), BLOCK_END, BLOCK_START, LocalPlayer::checkNewName(), ActorManager::findBeing(), ActorSprite::getId(), Viewport::getMap(), Being::getName(), Being::getParty(), Being::getTileX(), Being::getTileY(), Being::getType(), localPlayer, Actions::msg(), party, LocalPlayer::pingResponse(), ActorType::Player, ActorType::Portal, MapItemType::PORTAL, Avatar::setName(), Being::setName(), Being::updateColors(), Being::updateGuild(), ActorManager::updateNameId(), and viewport.

processPlayerMoveToAttack()

void Ea::BeingRecv::processPlayerMoveToAttack

(

Net::MessageIn &

msg

)

Definition at line 367 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processPlayerStop")
    msg.readInt32("target id");
    msg.readInt16("target x");
    msg.readInt16("target y");
    msg.readInt16("x");
    msg.readInt16("y");
    msg.readInt16("attack range");
 
    if (localPlayer != nullptr)
        localPlayer->fixAttackTarget();
    BLOCK_END("BeingRecv::processPlayerStop")
}

References BLOCK_END, BLOCK_START, LocalPlayer::fixAttackTarget(), localPlayer, and Actions::msg().

processPlayerStop()

void Ea::BeingRecv::processPlayerStop

(

Net::MessageIn &

msg

)

Definition at line 337 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processPlayerStop")
    if ((actorManager == nullptr) || (localPlayer == nullptr))
    {
        BLOCK_END("BeingRecv::processPlayerStop")
        return;
    }
 
    const BeingId id = msg.readBeingId("account id");
 
//    if (mSync || id != localPlayer->getId())
    {
        Being *const dstBeing = actorManager->findBeing(id);
        if (dstBeing != nullptr)
        {
            const uint16_t x = msg.readInt16("x");
            const uint16_t y = msg.readInt16("y");
            dstBeing->setTileCoords(x, y);
            if (dstBeing->getCurrentAction() == BeingAction::MOVE)
                dstBeing->setAction(BeingAction::STAND, 0);
            BLOCK_END("BeingRecv::processPlayerStop")
            return;
        }
    }
    msg.readInt16("x");
    msg.readInt16("y");
    BLOCK_END("BeingRecv::processPlayerStop")
}

References actorManager, BLOCK_END, BLOCK_START, ActorManager::findBeing(), Being::getCurrentAction(), localPlayer, BeingAction::MOVE, Actions::msg(), Being::setAction(), Being::setTileCoords(), BeingAction::STAND, x, and y.

processPvpMapMode()

void Ea::BeingRecv::processPvpMapMode

(

Net::MessageIn &

msg

)

Definition at line 402 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processPvpMapMode")
    const Game *const game = Game::instance();
    if (game == nullptr)
    {
        BLOCK_END("BeingRecv::processPvpMapMode")
        return;
    }
 
    Map *const map = game->getCurrentMap();
    if (map != nullptr)
        map->setPvpMode(msg.readInt16("pvp mode"));
    BLOCK_END("BeingRecv::processPvpMapMode")
}

References BLOCK_END, BLOCK_START, Game::getCurrentMap(), Game::instance(), Actions::msg(), and Map::setPvpMode().

processSkillNoDamage()

void Ea::BeingRecv::processSkillNoDamage

(

Net::MessageIn &

msg

)

Definition at line 382 of file beingrecv.cpp.

{
    if (actorManager == nullptr)
        return;
    const int id = msg.readInt16("skill id");
    int heal;
    if (msg.getVersion() >= 20131223)
        heal = msg.readInt32("heal");
    else
        heal = msg.readInt16("heal");
    Being *const dstBeing = actorManager->findBeing(
        msg.readBeingId("dst being id"));
    Being *const srcBeing = actorManager->findBeing(
        msg.readBeingId("src being id"));
    msg.readUInt8("fail");
 
    if (srcBeing != nullptr)
        srcBeing->handleSkill(dstBeing, heal, id, 1);
}

References actorManager, ActorManager::findBeing(), Being::handleSkill(), Actions::heal(), and Actions::msg().

Variable Documentation

mSpawnId

BeingId Ea::BeingRecv::mSpawnId = BeingId_zero

Definition at line 58 of file beingrecv.cpp.

Referenced by Ea::BeingHandler::BeingHandler(), EAthena::BeingRecv::processBeingMove(), TmwAthena::BeingRecv::processBeingMove(), EAthena::BeingRecv::processBeingSpawn(), TmwAthena::BeingRecv::processBeingSpawn(), EAthena::BeingRecv::processBeingVisible(), and TmwAthena::BeingRecv::processBeingVisible().

mSync

bool Ea::BeingRecv::mSync

extern

Referenced by Graphics::setSync().