TmwAthena::BeingRecv Namespace Reference

Functions
void	processBeingChangeLook (Net::MessageIn &msg)
void	processBeingChangeLook2 (Net::MessageIn &msg)
void	processBeingVisible (Net::MessageIn &msg)
void	processBeingMove (Net::MessageIn &msg)
void	processPlayerUpdate1 (Net::MessageIn &msg)
void	processPlayerUpdate2 (Net::MessageIn &msg)
void	processPlayerMove (Net::MessageIn &msg)
void	processBeingSpawn (Net::MessageIn &msg)
void	processSkillCasting (Net::MessageIn &msg)
void	processBeingStatusChange (Net::MessageIn &msg)
void	processBeingMove2 (Net::MessageIn &msg)
void	processBeingChangeDirection (Net::MessageIn &msg)
void	processBeingChangeLookContinue (const Net::MessageIn &msg, Being *const dstBeing, const uint8_t type, const int id, const int id2)
void	processPlayerStatusChange (Net::MessageIn &msg)
void	processBeingResurrect (Net::MessageIn &msg)
void	processPlayerGuilPartyInfo (Net::MessageIn &msg)
void	processBeingSelfEffect (Net::MessageIn &msg)
void	processSkillCastCancel (Net::MessageIn &msg)
void	processIpResponse (Net::MessageIn &msg)
void	processPvpSet (Net::MessageIn &msg)
void	processSkillDamage (Net::MessageIn &msg)
void	applyPlayerAction (Net::MessageIn &msg, Being *const being, const uint8_t type)
void	setServerGender (Being *const being, const uint8_t gender)

Function Documentation

applyPlayerAction()

void TmwAthena::BeingRecv::applyPlayerAction	(	Net::MessageIn &	msg,
		Being *const	being,
		const uint8_t	type
	)

Definition at line 1436 of file beingrecv.cpp.

{
    if (being == nullptr)
        return;
    switch (type)
    {
        case 0:
            being->setAction(BeingAction::STAND, 0);
            localPlayer->imitateAction(being, BeingAction::STAND);
            break;
 
        case 1:
            if (being->getCurrentAction() != BeingAction::DEAD)
            {
                being->setAction(BeingAction::DEAD, 0);
                being->recalcSpritesOrder();
            }
            break;
 
        case 2:
            being->setAction(BeingAction::SIT, 0);
            localPlayer->imitateAction(being, BeingAction::SIT);
            break;
 
        default:
            UNIMPLEMENTEDPACKETFIELD(type);
            break;
    }
}

References BeingAction::DEAD, Being::getCurrentAction(), LocalPlayer::imitateAction(), localPlayer, Being::recalcSpritesOrder(), Being::setAction(), BeingAction::SIT, BeingAction::STAND, and UNIMPLEMENTEDPACKETFIELD.

processBeingChangeDirection()

void TmwAthena::BeingRecv::processBeingChangeDirection

(

Net::MessageIn &

msg

)

Definition at line 1215 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processBeingChangeDirection")
    if (actorManager == nullptr)
    {
        BLOCK_END("BeingRecv::processBeingChangeDirection")
        return;
    }
 
    Being *const dstBeing = actorManager->findBeing(
        msg.readBeingId("being id"));
 
    if (dstBeing == nullptr)
    {
        DEBUGLOGSTR("invisible player?");
        msg.readInt16("unused");
        msg.readUInt8("direction");
        BLOCK_END("BeingRecv::processBeingChangeDirection");
        return;
    }
 
    msg.readInt16("unused");
 
    const uint8_t dir = Net::MessageIn::fromServerDirection(
        CAST_U8(msg.readUInt8("direction") & 0x0FU));
    dstBeing->setDirection(dir);
    if (localPlayer != nullptr)
        localPlayer->imitateDirection(dstBeing, dir);
    BLOCK_END("BeingRecv::processBeingChangeDirection")
}

References actorManager, BLOCK_END, BLOCK_START, CAST_U8, DEBUGLOGSTR, ActorManager::findBeing(), Net::MessageIn::fromServerDirection(), LocalPlayer::imitateDirection(), localPlayer, Actions::msg(), and Being::setDirection().

processBeingChangeLook()

void TmwAthena::BeingRecv::processBeingChangeLook

(

Net::MessageIn &

msg

)

Definition at line 78 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processBeingChangeLook")
    if (actorManager == nullptr)
    {
        BLOCK_END("BeingRecv::processBeingChangeLook")
        return;
    }
 
    Being *const dstBeing = actorManager->findBeing(
        msg.readBeingId("being id"));
 
    const uint8_t type = msg.readUInt8("type");
    const int16_t id = CAST_S16(msg.readUInt8("id"));
    const int id2 = 1;
 
    if ((localPlayer == nullptr) || (dstBeing == nullptr))
    {
        BLOCK_END("BeingRecv::processBeingChangeLook")
        return;
    }
    processBeingChangeLookContinue(msg, dstBeing, type, id, id2);
    BLOCK_END("BeingRecv::processBeingChangeLook")
}

References actorManager, BLOCK_END, BLOCK_START, CAST_S16, ActorManager::findBeing(), localPlayer, Actions::msg(), and EAthena::BeingRecv::processBeingChangeLookContinue().

processBeingChangeLook2()

void TmwAthena::BeingRecv::processBeingChangeLook2

(

Net::MessageIn &

msg

)

Definition at line 103 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processBeingChangeLook")
    if (actorManager == nullptr)
    {
        BLOCK_END("BeingRecv::processBeingChangeLook")
        return;
    }
 
    Being *const dstBeing = actorManager->findBeing(
        msg.readBeingId("being id"));
 
    const uint8_t type = msg.readUInt8("type");
    int id2 = 0;
 
    const int16_t id = msg.readInt16("id1");
    if (type == 2)
    {
        id2 = msg.readInt16("id2");
    }
    else
    {
        msg.readInt16("id2");
        id2 = 1;
    }
 
    if ((localPlayer == nullptr) || (dstBeing == nullptr))
    {
        BLOCK_END("BeingRecv::processBeingChangeLook")
        return;
    }
    processBeingChangeLookContinue(msg, dstBeing, type, id, id2);
    BLOCK_END("BeingRecv::processBeingChangeLook")
}

References actorManager, BLOCK_END, BLOCK_START, ActorManager::findBeing(), localPlayer, Actions::msg(), and EAthena::BeingRecv::processBeingChangeLookContinue().

processBeingChangeLookContinue()

void TmwAthena::BeingRecv::processBeingChangeLookContinue	(	const Net::MessageIn &	msg,
		Being *const	dstBeing,
		const uint8_t	type,
		const int	id,
		const int	id2
	)

Definition at line 138 of file beingrecv.cpp.

{
    if (dstBeing->getType() == ActorType::Player)
        dstBeing->setOtherTime();
 
    switch (type)
    {
        case 0:     // change race
            dstBeing->setSubtype(fromInt(id, BeingTypeId),
                dstBeing->getLook());
            break;
        case 1:     // eAthena LOOK_HAIR
        {
            const uint16_t look = CAST_U16(id / 256);
            const int hair = id % 256;
            dstBeing->setHairStyle(SPRITE_HAIR_COLOR, hair * -1);
            dstBeing->setLook(look);
            break;
        }
        case 2:     // Weapon ID in id, Shield ID in id2
            dstBeing->setSpriteId(SPRITE_BODY,
                id);
            dstBeing->setWeaponId(id);
            dstBeing->setSpriteId(SPRITE_FLOOR,
                id2);
            localPlayer->imitateOutfit(dstBeing, SPRITE_FLOOR);
            break;
        case 3:     // Change lower headgear for eAthena, pants for us
            dstBeing->setSpriteId(SPRITE_WEAPON,
                id);
            localPlayer->imitateOutfit(dstBeing, SPRITE_WEAPON);
            break;
        case 4:     // Change upper headgear for eAthena, hat for us
            dstBeing->setSpriteId(SPRITE_CLOTHES_COLOR,
                id);
            localPlayer->imitateOutfit(dstBeing, SPRITE_CLOTHES_COLOR);
            break;
        case 5:     // Change middle headgear for eathena, armor for us
            dstBeing->setSpriteId(SPRITE_HEAD_BOTTOM,
                id);
            localPlayer->imitateOutfit(dstBeing, SPRITE_HEAD_BOTTOM);
            break;
        case 6:     // eAthena LOOK_HAIR_COLOR
            dstBeing->setHairColor(SPRITE_HAIR_COLOR,
                fromInt(id, ItemColor));
            break;
        case 7:     // Clothes color
            // ignoring it
            break;
        case 8:     // eAthena LOOK_SHIELD
            dstBeing->setSpriteId(SPRITE_FLOOR,
                id);
            localPlayer->imitateOutfit(dstBeing, SPRITE_FLOOR);
            break;
        case 9:     // eAthena LOOK_SHOES
            dstBeing->setSpriteId(SPRITE_HAIR,
                id);
            localPlayer->imitateOutfit(dstBeing, SPRITE_HAIR);
            break;
        case 10:   // LOOK_GLOVES
            dstBeing->setSpriteId(SPRITE_SHOES,
                id);
            localPlayer->imitateOutfit(dstBeing, SPRITE_SHOES);
            break;
        case 11:  // LOOK_CAPE
            dstBeing->setSpriteId(SPRITE_SHIELD,
                id);
            localPlayer->imitateOutfit(dstBeing, SPRITE_SHIELD);
            break;
        case 12:
            dstBeing->setSpriteId(SPRITE_HEAD_TOP,
                id);
            localPlayer->imitateOutfit(dstBeing, SPRITE_HEAD_TOP);
            break;
        case 13:
            dstBeing->setSpriteId(SPRITE_HEAD_MID,
                id);
            localPlayer->imitateOutfit(dstBeing, SPRITE_HEAD_MID);
            break;
        case 14:
            dstBeing->setSpriteId(SPRITE_ROBE,
                id);
            localPlayer->imitateOutfit(dstBeing, SPRITE_ROBE);
            break;
        case 15:
            dstBeing->setSpriteId(SPRITE_EVOL2,
                id);
            localPlayer->imitateOutfit(dstBeing, SPRITE_EVOL2);
            break;
        case 16:
            dstBeing->setLook(CAST_U16(id));
            break;
        default:
            UNIMPLEMENTEDPACKETFIELD(type);
            break;
    }
}

References CAST_U16, fromInt, Being::getLook(), Being::getType(), LocalPlayer::imitateOutfit(), localPlayer, ActorType::Player, Being::setHairColor(), Being::setHairStyle(), Being::setLook(), Being::setOtherTime(), Being::setSpriteId(), Being::setSubtype(), Being::setWeaponId(), SPRITE_BODY, SPRITE_CLOTHES_COLOR, SPRITE_EVOL2, SPRITE_FLOOR, ItemDbType::SPRITE_HAIR, SPRITE_HAIR_COLOR, SPRITE_HEAD_BOTTOM, SPRITE_HEAD_MID, SPRITE_HEAD_TOP, SPRITE_ROBE, SPRITE_SHIELD, SPRITE_SHOES, SPRITE_WEAPON, and UNIMPLEMENTEDPACKETFIELD.

processBeingMove()

void TmwAthena::BeingRecv::processBeingMove

(

Net::MessageIn &

msg

)

Definition at line 918 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processBeingVisibleOrMove")
    if (actorManager == nullptr)
    {
        BLOCK_END("BeingRecv::processBeingVisibleOrMove")
        return;
    }
 
    BeingId spawnId;
 
    // Information about a being in range
    const BeingId id = msg.readBeingId("being id");
    if (id == Ea::BeingRecv::mSpawnId)
        spawnId = Ea::BeingRecv::mSpawnId;
    else
        spawnId = BeingId_zero;
    Ea::BeingRecv::mSpawnId = BeingId_zero;
    int16_t speed = msg.readInt16("speed");
    const uint32_t opt1 = msg.readInt16("opt1");
    const uint32_t opt2 = msg.readInt16("opt2");
    const uint32_t option = msg.readInt16("option");
    const int16_t job = msg.readInt16("class");
    int disguiseId = 0;
    if (id == localPlayer->getId() && job >= 1000)
        disguiseId = job;
 
    Being *dstBeing = actorManager->findBeing(id);
 
    if ((dstBeing != nullptr) && dstBeing->getType() == ActorType::Monster
        && !dstBeing->isAlive())
    {
        actorManager->destroy(dstBeing);
        actorManager->erase(dstBeing);
        dstBeing = nullptr;
    }
 
    if (dstBeing == nullptr)
    {
        // Being with id >= 110000000 and job 0 are better
        // known as ghosts, so don't create those.
        if (job == 0 && toInt(id, int) >= 110000000)
        {
            BLOCK_END("BeingRecv::processBeingVisibleOrMove")
            return;
        }
 
        if (actorManager->isBlocked(id) == true)
        {
            BLOCK_END("BeingRecv::processBeingVisibleOrMove")
            return;
        }
 
        dstBeing = Ea::BeingRecv::createBeing(id, job);
 
        if (dstBeing == nullptr)
        {
            BLOCK_END("BeingRecv::processBeingVisibleOrMove")
            return;
        }
    }
    else
    {
        if (dstBeing->getType() == ActorType::Npc)
        {
            actorManager->undelete(dstBeing);
            beingHandler->requestNameById(id);
        }
    }
 
    if (dstBeing->getType() == ActorType::Player)
        dstBeing->setMoveTime();
 
    if (spawnId != BeingId_zero)
        dstBeing->setAction(BeingAction::SPAWN, 0);
 
    // Prevent division by 0 when calculating frame
    if (speed == 0)
        speed = 150;
 
    const uint8_t hairStyle = msg.readUInt8("hair style");
    const uint16_t look = msg.readUInt8("look");
    dstBeing->setSubtype(fromInt(job, BeingTypeId), look);
    if (dstBeing->getType() == ActorType::Monster && (localPlayer != nullptr))
        localPlayer->checkNewName(dstBeing);
    dstBeing->setWalkSpeed(speed);
    const uint16_t weapon = msg.readInt16("weapon");
    const uint16_t headBottom = msg.readInt16("head bottom");
 
    msg.readInt32("tick");
 
    const uint16_t shield = msg.readInt16("shield");
    const uint16_t headTop = msg.readInt16("head top");
    const uint16_t headMid = msg.readInt16("head mid");
    const ItemColor hairColor = fromInt(
        msg.readUInt8("hair color"), ItemColor);
    msg.readUInt8("unused");
    const uint16_t shoes = msg.readInt16("shoes / clothes color");
 
    uint16_t gloves;
    if (dstBeing->getType() == ActorType::Monster)
    {
        if (serverFeatures->haveServerHp())
        {
            const int hp = msg.readInt32("hp");
            const int maxHP = msg.readInt32("max hp");
            if ((hp != 0) && (maxHP != 0))
            {
                dstBeing->setMaxHP(maxHP);
                const int oldHP = dstBeing->getHP();
                if ((oldHP == 0) || oldHP > hp)
                    dstBeing->setHP(hp);
            }
        }
        else
        {
            msg.readInt32("unused");
            msg.readInt32("unused");
        }
        gloves = 0;
    }
    else
    {
        gloves = msg.readInt16("gloves / head dir");
        msg.readInt32("guild");
        msg.readInt16("guild emblem");
    }
 
    dstBeing->setManner(msg.readInt16("manner"));
    const uint32_t opt3 = msg.readInt16("opt3");
    if (serverFeatures->haveMonsterAttackRange()
        && dstBeing->getType() == ActorType::Monster)
    {
        const int attackRange = CAST_S32(
            msg.readUInt8("attack range (was karma)"));
        dstBeing->setAttackRange(attackRange);
    }
    else
    {
        dstBeing->setKarma(msg.readUInt8("karma"));
    }
    uint8_t gender = msg.readUInt8("gender");
 
    if ((disguiseId == 0) && dstBeing->getType() == ActorType::Player)
    {
        // reserving bits for future usage
        gender &= 3;
        dstBeing->setGender(Being::intToGender(gender));
        // Set these after the gender, as the sprites may be gender-specific
        if (hairStyle == 0)
        {
            dstBeing->updateSprite(SPRITE_HAIR_COLOR, 0, std::string());
        }
        else
        {
            dstBeing->updateSprite(SPRITE_HAIR_COLOR,
                hairStyle * -1,
                ItemDB::get(-hairStyle).getDyeColorsString(hairColor));
        }
        dstBeing->setHairColor(hairColor);
        dstBeing->updateSprite(SPRITE_WEAPON, headBottom, std::string());
        dstBeing->updateSprite(SPRITE_HEAD_BOTTOM, headMid, std::string());
        dstBeing->updateSprite(SPRITE_CLOTHES_COLOR, headTop, std::string());
        dstBeing->updateSprite(SPRITE_HAIR, shoes, std::string());
        dstBeing->updateSprite(SPRITE_SHOES, gloves, std::string());
        dstBeing->updateSprite(SPRITE_BODY, weapon, std::string());
        dstBeing->setWeaponId(weapon);
        dstBeing->updateSprite(SPRITE_FLOOR, shield, std::string());
    }
    else if (dstBeing->getType() == ActorType::Npc
             && serverFeatures->haveNpcGender())
    {
        setServerGender(dstBeing, gender);
    }
 
    uint16_t srcX;
    uint16_t srcY;
    uint16_t dstX;
    uint16_t dstY;
    msg.readCoordinatePair(srcX, srcY, dstX, dstY, "move path");
    if (disguiseId == 0)
    {
        dstBeing->setAction(BeingAction::STAND, 0);
        dstBeing->setTileCoords(srcX, srcY);
        if (serverFeatures->haveMove3())
            dstBeing->setCachedDestination(dstX, dstY);
        else
            dstBeing->setDestination(dstX, dstY);
    }
 
    msg.readUInt8("unknown");
    msg.readUInt8("unknown");
    msg.readUInt8("unknown");
    msg.readUInt8("unknown");
    msg.readUInt8("unknown");
 
    dstBeing->setStatusEffectOpitons(option,
        opt1,
        opt2,
        opt3);
    BLOCK_END("BeingRecv::processBeingVisibleOrMove")
}

References actorManager, beingHandler, BeingId_zero, BLOCK_END, BLOCK_START, CAST_S32, LocalPlayer::checkNewName(), Ea::BeingRecv::createBeing(), ActorManager::destroy(), ActorManager::erase(), ActorManager::findBeing(), fromInt, ItemDB::get(), Being::getHP(), ActorSprite::getId(), Being::getType(), Net::ServerFeatures::haveMonsterAttackRange(), Net::ServerFeatures::haveMove3(), Net::ServerFeatures::haveNpcGender(), Net::ServerFeatures::haveServerHp(), Being::intToGender(), Being::isAlive(), ActorManager::isBlocked(), localPlayer, ActorType::Monster, Actions::msg(), Ea::BeingRecv::mSpawnId, ActorType::Npc, ActorType::Player, Net::BeingHandler::requestNameById(), serverFeatures, Being::setAction(), Being::setAttackRange(), Being::setCachedDestination(), Being::setDestination(), Being::setGender(), Being::setHairColor(), Being::setHP(), Being::setKarma(), Being::setManner(), Being::setMaxHP(), Being::setMoveTime(), setServerGender(), ActorSprite::setStatusEffectOpitons(), Being::setSubtype(), Being::setTileCoords(), Being::setWalkSpeed(), Being::setWeaponId(), BeingAction::SPAWN, SPRITE_BODY, SPRITE_CLOTHES_COLOR, SPRITE_FLOOR, ItemDbType::SPRITE_HAIR, SPRITE_HAIR_COLOR, SPRITE_HEAD_BOTTOM, SPRITE_SHOES, SPRITE_WEAPON, BeingAction::STAND, toInt, ActorManager::undelete(), and Being::updateSprite().

processBeingMove2()

void TmwAthena::BeingRecv::processBeingMove2

(

Net::MessageIn &

msg

)

Definition at line 1171 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processBeingMove2")
    if (actorManager == nullptr)
    {
        BLOCK_END("BeingRecv::processBeingMove2")
        return;
    }
 
    /*
      * A simplified movement packet, used by the
      * later versions of eAthena for both mobs and
      * players
      */
    Being *const dstBeing = actorManager->findBeing(
        msg.readBeingId("being id"));
 
    /*
      * This packet doesn't have enough info to actually
      * create a new being, so if the being isn't found,
      * we'll just pretend the packet didn't happen
      */
 
    if (dstBeing == nullptr)
    {
        BLOCK_END("BeingRecv::processBeingMove2")
        return;
    }
 
    uint16_t srcX;
    uint16_t srcY;
    uint16_t dstX;
    uint16_t dstY;
    msg.readCoordinatePair(srcX, srcY, dstX, dstY, "move path");
    msg.readInt32("tick");
 
    dstBeing->setAction(BeingAction::STAND, 0);
    dstBeing->setTileCoords(srcX, srcY);
    dstBeing->setDestination(dstX, dstY);
    if (dstBeing->getType() == ActorType::Player)
        dstBeing->setMoveTime();
    BLOCK_END("BeingRecv::processBeingMove2")
}

References actorManager, BLOCK_END, BLOCK_START, ActorManager::findBeing(), Being::getType(), Actions::msg(), ActorType::Player, Being::setAction(), Being::setDestination(), Being::setMoveTime(), Being::setTileCoords(), and BeingAction::STAND.

processBeingResurrect()

void TmwAthena::BeingRecv::processBeingResurrect

(

Net::MessageIn &

msg

)

Definition at line 1279 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processBeingResurrect")
    if (actorManager == nullptr || localPlayer == nullptr)
    {
        BLOCK_END("BeingRecv::processBeingResurrect")
        return;
    }
 
    // A being changed mortality status
 
    const BeingId id = msg.readBeingId("being id");
    Being *const dstBeing = actorManager->findBeing(id);
    if (dstBeing == nullptr)
    {
        DEBUGLOGSTR("insible player?");
        msg.readInt16("flag?");
        BLOCK_END("BeingRecv::processBeingResurrect")
        return;
    }
 
    // If this is player's current target, clear it.
    if (dstBeing == localPlayer->getTarget())
        localPlayer->stopAttack(false);
    if (dstBeing == localPlayer &&
        deathNotice != nullptr)
    {
        deathNotice->scheduleDelete();
        deathNotice = nullptr;
    }
 
    if (msg.readInt16("flag?") == 1)
        dstBeing->setAction(BeingAction::STAND, 0);
    BLOCK_END("BeingRecv::processBeingResurrect")
}

References actorManager, BLOCK_END, BLOCK_START, deathNotice, DEBUGLOGSTR, ActorManager::findBeing(), LocalPlayer::getTarget(), localPlayer, Actions::msg(), Window::scheduleDelete(), Being::setAction(), BeingAction::STAND, and LocalPlayer::stopAttack().

processBeingSelfEffect()

void TmwAthena::BeingRecv::processBeingSelfEffect

(

Net::MessageIn &

msg

)

Definition at line 1353 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processBeingSelfEffect")
    if ((effectManager == nullptr) || (actorManager == nullptr))
    {
        BLOCK_END("BeingRecv::processBeingSelfEffect")
        return;
    }
 
    const BeingId id = msg.readBeingId("being id");
    Being *const being = actorManager->findBeing(id);
    if (being == nullptr)
    {
        DEBUGLOGSTR("insible player?");
        msg.readInt32("effect type");
        BLOCK_END("BeingRecv::processBeingSelfEffect")
        return;
    }
 
    const int effectType = msg.readInt32("effect type");
 
    if (ParticleEngine::enabled)
        effectManager->trigger(effectType, being, 0);
 
    // +++ need dehard code effectType == 3
    if (effectType == 3 && being->getType() == ActorType::Player
        && (socialWindow != nullptr))
    {   // reset received damage
        socialWindow->resetDamage(being->getName());
    }
    BLOCK_END("BeingRecv::processBeingSelfEffect")
}

References actorManager, BLOCK_END, BLOCK_START, DEBUGLOGSTR, effectManager, ParticleEngine::enabled, ActorManager::findBeing(), Being::getName(), Being::getType(), Actions::msg(), ActorType::Player, SocialWindow::resetDamage(), socialWindow, and EffectManager::trigger().

processBeingSpawn()

void TmwAthena::BeingRecv::processBeingSpawn

(

Net::MessageIn &

msg

)

Definition at line 1121 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processBeingSpawn")
    // skipping this packet
    Ea::BeingRecv::mSpawnId = msg.readBeingId("being id");
    msg.readInt16("speed");
    msg.readInt16("opt1");
    msg.readInt16("opt2");
    msg.readInt16("option");
    msg.readInt16("disguise");
    msg.skip(25, "unused");
    BLOCK_END("BeingRecv::processBeingSpawn")
}

References BLOCK_END, BLOCK_START, Actions::msg(), and Ea::BeingRecv::mSpawnId.

processBeingStatusChange()

void TmwAthena::BeingRecv::processBeingStatusChange

(

Net::MessageIn &

msg

)

Definition at line 1146 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processBeingStatusChange")
    if (actorManager == nullptr)
    {
        BLOCK_END("BeingRecv::processBeingStatusChange")
        return;
    }
 
    // Status change
    const uint16_t status = msg.readInt16("status");
    const BeingId id = msg.readBeingId("being id");
    const Enable flag = fromBool(
        msg.readUInt8("flag: 0: stop, 1: start"), Enable);
 
    Being *const dstBeing = actorManager->findBeing(id);
    if (dstBeing != nullptr)
    {
        // dont know on legacy servers is effect really started
        // or not. Because this always sending IsStart_true
        dstBeing->setStatusEffect(status, flag, IsStart_true);
    }
    BLOCK_END("BeingRecv::processBeingStatusChange")
}

References actorManager, BLOCK_END, BLOCK_START, ActorManager::findBeing(), fromBool, IsStart_true, Actions::msg(), and ActorSprite::setStatusEffect().

processBeingVisible()

void TmwAthena::BeingRecv::processBeingVisible

(

Net::MessageIn &

msg

)

Definition at line 702 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processBeingVisibleOrMove")
    if (actorManager == nullptr)
    {
        BLOCK_END("BeingRecv::processBeingVisibleOrMove")
        return;
    }
 
    BeingId spawnId;
 
    // Information about a being in range
    const BeingId id = msg.readBeingId("being id");
    if (id == Ea::BeingRecv::mSpawnId)
        spawnId = Ea::BeingRecv::mSpawnId;
    else
        spawnId = BeingId_zero;
    Ea::BeingRecv::mSpawnId = BeingId_zero;
    int16_t speed = msg.readInt16("speed");
    const uint32_t opt1 = msg.readInt16("opt1");
    const uint32_t opt2 = msg.readInt16("opt2");
    const uint32_t option = msg.readInt16("option");
    const int16_t job = msg.readInt16("class");
    int disguiseId = 0;
    if (id == localPlayer->getId() && job >= 1000)
        disguiseId = job;
 
    Being *dstBeing = actorManager->findBeing(id);
 
    if ((dstBeing != nullptr) && dstBeing->getType() == ActorType::Monster
        && !dstBeing->isAlive())
    {
        actorManager->destroy(dstBeing);
        actorManager->erase(dstBeing);
        dstBeing = nullptr;
    }
 
    if (dstBeing == nullptr)
    {
        // Being with id >= 110000000 and job 0 are better
        // known as ghosts, so don't create those.
        if (job == 0 && toInt(id, int) >= 110000000)
        {
            BLOCK_END("BeingRecv::processBeingVisibleOrMove")
            return;
        }
 
        if (actorManager->isBlocked(id) == true)
        {
            BLOCK_END("BeingRecv::processBeingVisibleOrMove")
            return;
        }
 
        dstBeing = Ea::BeingRecv::createBeing(id, job);
 
        if (dstBeing == nullptr)
        {
            BLOCK_END("BeingRecv::processBeingVisibleOrMove")
            return;
        }
    }
    else
    {
        if (dstBeing->getType() == ActorType::Npc)
        {
            actorManager->undelete(dstBeing);
            beingHandler->requestNameById(id);
        }
    }
 
    if (dstBeing->getType() == ActorType::Player)
        dstBeing->setMoveTime();
 
    if (spawnId != BeingId_zero)
    {
        dstBeing->setAction(BeingAction::SPAWN, 0);
    }
    else
    {
        dstBeing->clearPath();
        dstBeing->setActionTime(tick_time);
        dstBeing->setAction(BeingAction::STAND, 0);
    }
 
    // Prevent division by 0 when calculating frame
    if (speed == 0)
        speed = 150;
 
    const uint8_t hairStyle = msg.readUInt8("hair style");
    const uint16_t look = msg.readUInt8("look");
    dstBeing->setSubtype(fromInt(job, BeingTypeId), look);
    if (dstBeing->getType() == ActorType::Monster && (localPlayer != nullptr))
        localPlayer->checkNewName(dstBeing);
    dstBeing->setWalkSpeed(speed);
    const uint16_t weapon = msg.readInt16("weapon");
    const uint16_t headBottom = msg.readInt16("head bottom");
 
    const uint16_t shield = msg.readInt16("shield");
    const uint16_t headTop = msg.readInt16("head top");
    const uint16_t headMid = msg.readInt16("head mid");
    const ItemColor hairColor = fromInt(msg.readUInt8("hair color"),
        ItemColor);
    msg.readUInt8("unused");
    const uint16_t shoes = msg.readInt16("shoes / clothes color");
 
    uint16_t gloves;
    if (dstBeing->getType() == ActorType::Monster)
    {
        if (serverFeatures->haveServerHp())
        {
            const int hp = msg.readInt32("hp");
            const int maxHP = msg.readInt32("max hp");
            if ((hp != 0) && (maxHP != 0))
            {
                dstBeing->setMaxHP(maxHP);
                const int oldHP = dstBeing->getHP();
                if ((oldHP == 0) || oldHP > hp)
                    dstBeing->setHP(hp);
            }
        }
        else
        {
            msg.readInt32("unused");
            msg.readInt32("unused");
        }
        gloves = 0;
    }
    else
    {
        gloves = msg.readInt16("gloves / head dir");
        msg.readInt32("guild");
        msg.readInt16("guild emblem");
    }
 
    dstBeing->setManner(msg.readInt16("manner"));
    const uint32_t opt3 = msg.readInt16("opt3");
    if (serverFeatures->haveMonsterAttackRange()
        && dstBeing->getType() == ActorType::Monster)
    {
        const int attackRange = CAST_S32(
            msg.readUInt8("attack range (was karma)"));
        dstBeing->setAttackRange(attackRange);
    }
    else
    {
        dstBeing->setKarma(msg.readUInt8("karma"));
    }
    uint8_t gender = msg.readUInt8("gender");
 
    if ((disguiseId == 0) && dstBeing->getType() == ActorType::Player)
    {
        // reserving bits for future usage
        gender &= 3;
        dstBeing->setGender(Being::intToGender(gender));
        // Set these after the gender, as the sprites may be gender-specific
        if (hairStyle == 0)
        {
            dstBeing->updateSprite(SPRITE_HAIR_COLOR, 0, std::string());
        }
        else
        {
            dstBeing->updateSprite(SPRITE_HAIR_COLOR,
                hairStyle * -1,
                ItemDB::get(-hairStyle).getDyeColorsString(hairColor));
        }
        dstBeing->setHairColor(hairColor);
        dstBeing->updateSprite(SPRITE_WEAPON, headBottom, std::string());
        dstBeing->updateSprite(SPRITE_HEAD_BOTTOM, headMid, std::string());
        dstBeing->updateSprite(SPRITE_CLOTHES_COLOR, headTop, std::string());
        dstBeing->updateSprite(SPRITE_HAIR, shoes, std::string());
        dstBeing->updateSprite(SPRITE_SHOES, gloves, std::string());
        dstBeing->updateSprite(SPRITE_BODY, weapon, std::string());
        dstBeing->setWeaponId(weapon);
        dstBeing->updateSprite(SPRITE_FLOOR, shield, std::string());
    }
    else if (dstBeing->getType() == ActorType::Npc
             && serverFeatures->haveNpcGender())
    {
        setServerGender(dstBeing, gender);
    }
 
    uint8_t dir;
    uint16_t x;
    uint16_t y;
    msg.readCoordinates(x, y, dir, "position");
    dstBeing->setTileCoords(x, y);
 
    if (job == 45 && (socialWindow != nullptr) && (outfitWindow != nullptr))
    {
        const int num = socialWindow->getPortalIndex(x, y);
        if (num >= 0)
        {
            dstBeing->setName(KeyboardConfig::getKeyShortString(
                OutfitWindow::keyName(num)));
        }
        else
        {
            dstBeing->setName("");
        }
    }
 
    dstBeing->setDirection(dir);
 
    msg.readUInt8("unknown");
    msg.readUInt8("unknown");
    msg.readUInt8("unknown");
    msg.readUInt8("unknown");
    msg.readUInt8("unknown");
 
    dstBeing->setStatusEffectOpitons(option,
        opt1,
        opt2,
        opt3);
    BLOCK_END("BeingRecv::processBeingVisibleOrMove")
}

References actorManager, beingHandler, BeingId_zero, BLOCK_END, BLOCK_START, CAST_S32, LocalPlayer::checkNewName(), Being::clearPath(), Ea::BeingRecv::createBeing(), ActorManager::destroy(), ActorManager::erase(), ActorManager::findBeing(), fromInt, ItemDB::get(), Being::getHP(), ActorSprite::getId(), KeyboardConfig::getKeyShortString(), SocialWindow::getPortalIndex(), Being::getType(), Net::ServerFeatures::haveMonsterAttackRange(), Net::ServerFeatures::haveNpcGender(), Net::ServerFeatures::haveServerHp(), Being::intToGender(), Being::isAlive(), ActorManager::isBlocked(), OutfitWindow::keyName(), localPlayer, ActorType::Monster, Actions::msg(), Ea::BeingRecv::mSpawnId, ActorType::Npc, outfitWindow, ActorType::Player, Net::BeingHandler::requestNameById(), serverFeatures, Being::setAction(), Being::setActionTime(), Being::setAttackRange(), Being::setDirection(), Being::setGender(), Being::setHairColor(), Being::setHP(), Being::setKarma(), Being::setManner(), Being::setMaxHP(), Being::setMoveTime(), Being::setName(), setServerGender(), ActorSprite::setStatusEffectOpitons(), Being::setSubtype(), Being::setTileCoords(), Being::setWalkSpeed(), Being::setWeaponId(), socialWindow, BeingAction::SPAWN, SPRITE_BODY, SPRITE_CLOTHES_COLOR, SPRITE_FLOOR, ItemDbType::SPRITE_HAIR, SPRITE_HAIR_COLOR, SPRITE_HEAD_BOTTOM, SPRITE_SHOES, SPRITE_WEAPON, BeingAction::STAND, tick_time, toInt, ActorManager::undelete(), Being::updateSprite(), x, and y.

processIpResponse()

void TmwAthena::BeingRecv::processIpResponse

(

Net::MessageIn &

msg

)

Definition at line 1391 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processIpResponse")
    if (actorManager == nullptr)
    {
        BLOCK_END("BeingRecv::processIpResponse")
        return;
    }
 
    Being *const dstBeing = actorManager->findBeing(
        msg.readBeingId("being id"));
    if (dstBeing != nullptr)
    {
        const std::string ip = ipToString(msg.readInt32("ip address"));
        dstBeing->setIp(ip);
    }
    else
    {
        msg.readInt32("ip address");
        DEBUGLOGSTR("invisible player?");
    }
 
    BLOCK_END("BeingRecv::processIpResponse")
}

References actorManager, BLOCK_END, BLOCK_START, DEBUGLOGSTR, ActorManager::findBeing(), ipToString(), Actions::msg(), and Being::setIp().

processPlayerGuilPartyInfo()

void TmwAthena::BeingRecv::processPlayerGuilPartyInfo

(

Net::MessageIn &

msg

)

Definition at line 1315 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processPlayerGuilPartyInfo")
    if (actorManager == nullptr)
    {
        BLOCK_END("BeingRecv::processPlayerGuilPartyInfo")
        return;
    }
 
    Being *const dstBeing = actorManager->findBeing(
        msg.readBeingId("being id"));
 
    if (dstBeing != nullptr)
    {
        dstBeing->setPartyName(msg.readString(24, "party name"));
        if ((guildManager == nullptr) || !GuildManager::getEnableGuildBot())
        {
            dstBeing->setGuildName(msg.readString(24, "guild name"));
            dstBeing->setGuildPos(msg.readString(24, "guild pos"));
        }
        else
        {
            msg.readString(24, "guild name");
            msg.readString(24, "guild pos");
        }
        dstBeing->addToCache();
        msg.readString(24, "?");
    }
    else
    {
        msg.readString(24, "party name");
        msg.readString(24, "guild name");
        msg.readString(24, "guild pos");
        msg.readString(24, "?");
    }
    BLOCK_END("BeingRecv::processPlayerGuilPartyInfo")
}

References actorManager, Being::addToCache(), BLOCK_END, BLOCK_START, ActorManager::findBeing(), GuildManager::getEnableGuildBot(), guildManager, Actions::msg(), Being::setGuildName(), Being::setGuildPos(), and Being::setPartyName().

processPlayerMove()

void TmwAthena::BeingRecv::processPlayerMove

(

Net::MessageIn &

msg

)

Definition at line 528 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processPlayerMoveUpdate")
    if ((actorManager == nullptr) || (localPlayer == nullptr))
    {
        BLOCK_END("BeingRecv::processPlayerMoveUpdate")
        return;
    }
 
    // An update about a player, potentially including movement.
    const BeingId id = msg.readBeingId("account id");
    const int16_t speed = msg.readInt16("speed");
    const uint32_t opt1 = msg.readInt16("opt1");
    const uint32_t opt2 = msg.readInt16("opt2");
    const uint32_t option = msg.readInt16("option");
    const int16_t job = msg.readInt16("job");
    int disguiseId = 0;
    if (toInt(id, int) < 110000000 && job >= 1000)
        disguiseId = job;
 
    Being *dstBeing = actorManager->findBeing(id);
    if (dstBeing == nullptr)
    {
        if (actorManager->isBlocked(id) == true)
        {
            BLOCK_END("BeingRecv::processPlayerMoveUpdate")
            return;
        }
 
        dstBeing = Ea::BeingRecv::createBeing(id, job);
 
        if (dstBeing == nullptr)
        {
            BLOCK_END("BeingRecv::processPlayerMoveUpdate")
            return;
        }
    }
    else if (disguiseId != 0)
    {
        actorManager->undelete(dstBeing);
        beingHandler->requestNameById(id);
    }
 
    const uint8_t dir = dstBeing->getDirectionDelayed();
    if (dir != 0U)
    {
        if (dir != dstBeing->getDirection())
            dstBeing->setDirection(dir);
    }
 
    if (Party *const party = localPlayer->getParty())
    {
        if (party->isMember(id))
            dstBeing->setParty(party);
    }
 
    dstBeing->setWalkSpeed(speed);
 
    const uint8_t hairStyle = msg.readUInt8("hair style");
    const uint16_t look = msg.readUInt8("look");
    dstBeing->setSubtype(fromInt(job, BeingTypeId), look);
    const uint16_t weapon = msg.readInt16("weapon");
    const uint16_t shield = msg.readInt16("shield");
    const uint16_t headBottom = msg.readInt16("head bottom");
 
    msg.readInt32("tick");
 
    const uint16_t headTop = msg.readInt16("head top");
    const uint16_t headMid = msg.readInt16("head mid");
    const ItemColor hairColor = fromInt(
        msg.readUInt8("hair color"), ItemColor);
    msg.readUInt8("unused");
    msg.readInt32("unused");
 
    const int guild = msg.readInt32("guild");
 
    if ((guildManager == nullptr) || !GuildManager::getEnableGuildBot())
    {
        if (guild == 0)
            dstBeing->clearGuilds();
        else
            dstBeing->setGuild(Guild::getGuild(CAST_S16(guild)));
    }
 
    msg.readInt16("emblem");
    dstBeing->setManner(msg.readInt16("manner"));
    const uint32_t opt3 = msg.readInt16("opt3");
    dstBeing->setKarma(msg.readUInt8("karma"));
    // reserving bit for future usage
    dstBeing->setGender(Being::intToGender(
        CAST_U8(msg.readUInt8("gender") & 3)));
 
    if (disguiseId == 0)
    {
        // Set these after the gender, as the sprites may be gender-specific
        dstBeing->updateSprite(SPRITE_BODY,
            weapon,
            std::string());
        dstBeing->setWeaponId(weapon);
        dstBeing->updateSprite(SPRITE_FLOOR, shield, std::string());
        dstBeing->updateSprite(SPRITE_WEAPON, headBottom, std::string());
        dstBeing->updateSprite(SPRITE_HEAD_BOTTOM, headMid, std::string());
        dstBeing->updateSprite(SPRITE_CLOTHES_COLOR, headTop, std::string());
        if (hairStyle == 0)
        {
            dstBeing->updateSprite(SPRITE_HAIR_COLOR,
                0,
                std::string());
        }
        else
        {
            dstBeing->updateSprite(SPRITE_HAIR_COLOR,
                hairStyle * -1,
                ItemDB::get(-hairStyle).getDyeColorsString(hairColor));
        }
        dstBeing->setHairColor(hairColor);
    }
    localPlayer->imitateOutfit(dstBeing, -1);
 
    uint16_t srcX;
    uint16_t srcY;
    uint16_t dstX;
    uint16_t dstY;
    msg.readCoordinatePair(srcX, srcY, dstX, dstY, "moving path");
 
    localPlayer->followMoveTo(dstBeing, srcX, srcY, dstX, dstY);
 
    dstBeing->setTileCoords(srcX, srcY);
    dstBeing->setDestination(dstX, dstY);
 
    // because server don't send direction in move packet,
    // we fixing it
 
    if (srcX != dstX || srcY != dstY)
    {
        const int d = dstBeing->calcDirection(dstX, dstY);
 
        if ((d != 0) && dstBeing->getDirection() != d)
            dstBeing->setDirectionDelayed(CAST_U8(d));
    }
 
    if (localPlayer->getCurrentAction() != BeingAction::STAND)
        localPlayer->imitateAction(dstBeing, BeingAction::STAND);
    if (localPlayer->getDirection() != dstBeing->getDirection())
    {
        localPlayer->imitateDirection(dstBeing,
            dstBeing->getDirection());
    }
 
    const uint16_t gmstatus = msg.readInt16("gm status");
 
    setGm(dstBeing, gmstatus);
 
    msg.readUInt8("unused");
 
    const int level = CAST_S32(msg.readUInt8("level"));
    if (level != 0)
        dstBeing->setLevel(level);
 
    msg.readUInt8("unused");
 
    if (dstBeing->getType() != ActorType::Player)
        dstBeing->setActionTime(tick_time);
 
    dstBeing->setStatusEffectOpitons(option,
        opt1,
        opt2,
        opt3);
 
    if (dstBeing->getType() == ActorType::Player)
        dstBeing->setMoveTime();
    BLOCK_END("BeingRecv::processPlayerMoveUpdate")
}

References actorManager, beingHandler, BLOCK_END, BLOCK_START, Being::calcDirection(), CAST_S16, CAST_S32, CAST_U8, Being::clearGuilds(), Ea::BeingRecv::createBeing(), ActorManager::findBeing(), LocalPlayer::followMoveTo(), fromInt, ItemDB::get(), Being::getCurrentAction(), Being::getDirection(), Being::getDirectionDelayed(), GuildManager::getEnableGuildBot(), Guild::getGuild(), Being::getParty(), Being::getType(), guild, guildManager, LocalPlayer::imitateAction(), LocalPlayer::imitateDirection(), LocalPlayer::imitateOutfit(), Being::intToGender(), ActorManager::isBlocked(), localPlayer, Actions::msg(), party, ActorType::Player, Net::BeingHandler::requestNameById(), Being::setActionTime(), Being::setDestination(), Being::setDirection(), Being::setDirectionDelayed(), Being::setGender(), TmwAthena::setGm(), Being::setGuild(), Being::setHairColor(), Being::setKarma(), Being::setLevel(), Being::setManner(), Being::setMoveTime(), Being::setParty(), ActorSprite::setStatusEffectOpitons(), Being::setSubtype(), Being::setTileCoords(), Being::setWalkSpeed(), Being::setWeaponId(), SPRITE_BODY, SPRITE_CLOTHES_COLOR, SPRITE_FLOOR, SPRITE_HAIR_COLOR, SPRITE_HEAD_BOTTOM, SPRITE_WEAPON, BeingAction::STAND, tick_time, toInt, ActorManager::undelete(), and Being::updateSprite().

processPlayerStatusChange()

void TmwAthena::BeingRecv::processPlayerStatusChange

(

Net::MessageIn &

msg

)

Definition at line 1246 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processPlayerStop")
    if (actorManager == nullptr)
    {
        BLOCK_END("BeingRecv::processPlayerStop")
        return;
    }
 
    // Change in players' flags
    const BeingId id = msg.readBeingId("account id");
    Being *const dstBeing = actorManager->findBeing(id);
    if (dstBeing == nullptr)
    {
        DEBUGLOGSTR("invisible player?");
        msg.readInt16("stun mode");
        msg.readInt16("status effect");
        msg.readInt16("opt?");
        msg.readUInt8("Unused?");
        return;
    }
 
    const uint32_t opt1 = msg.readInt16("opt1");
    const uint32_t opt2 = msg.readInt16("opt2");
    const uint32_t option = msg.readInt16("option");
    msg.readUInt8("Unused?");
 
    dstBeing->setStatusEffectOpitons(option,
        opt1,
        opt2);
    BLOCK_END("BeingRecv::processPlayerStop")
}

References actorManager, BLOCK_END, BLOCK_START, DEBUGLOGSTR, ActorManager::findBeing(), Actions::msg(), and ActorSprite::setStatusEffectOpitons().

processPlayerUpdate1()

void TmwAthena::BeingRecv::processPlayerUpdate1

(

Net::MessageIn &

msg

)

Definition at line 240 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processPlayerMoveUpdate")
    if ((actorManager == nullptr) || (localPlayer == nullptr))
    {
        BLOCK_END("BeingRecv::processPlayerMoveUpdate")
        return;
    }
 
    // An update about a player, potentially including movement.
    const BeingId id = msg.readBeingId("account id");
    const int16_t speed = msg.readInt16("speed");
    const uint32_t opt1 = msg.readInt16("opt1");
    const uint32_t opt2 = msg.readInt16("opt2");
    const uint32_t option = msg.readInt16("option");
    const int16_t job = msg.readInt16("job");
    int disguiseId = 0;
    if (toInt(id, int) < 110000000 && job >= 1000)
        disguiseId = job;
 
    Being *dstBeing = actorManager->findBeing(id);
    if (dstBeing == nullptr)
    {
        if (actorManager->isBlocked(id) == true)
        {
            BLOCK_END("BeingRecv::processPlayerMoveUpdate")
            return;
        }
 
        dstBeing = Ea::BeingRecv::createBeing(id, job);
 
        if (dstBeing == nullptr)
        {
            BLOCK_END("BeingRecv::processPlayerMoveUpdate")
            return;
        }
    }
    else if (disguiseId != 0)
    {
        actorManager->undelete(dstBeing);
        beingHandler->requestNameById(id);
    }
 
    uint8_t dir = dstBeing->getDirectionDelayed();
    if (dir != 0U)
    {
        if (dir != dstBeing->getDirection())
            dstBeing->setDirection(dir);
    }
 
    if (Party *const party = localPlayer->getParty())
    {
        if (party->isMember(id))
            dstBeing->setParty(party);
    }
 
    dstBeing->setWalkSpeed(speed);
 
    const uint8_t hairStyle = msg.readUInt8("hair style");
    const uint16_t look = msg.readUInt8("look");
    dstBeing->setSubtype(fromInt(job, BeingTypeId), look);
    const uint16_t weapon = msg.readInt16("weapon");
    const uint16_t shield = msg.readInt16("shield");
    const uint16_t headBottom = msg.readInt16("head bottom");
 
    const uint16_t headTop = msg.readInt16("head top");
    const uint16_t headMid = msg.readInt16("head mid");
    const ItemColor hairColor = fromInt(
        msg.readUInt8("hair color"), ItemColor);
    msg.readUInt8("unused");
    msg.readInt32("unused");
 
    const int guild = msg.readInt32("guild");
 
    if ((guildManager == nullptr) || !GuildManager::getEnableGuildBot())
    {
        if (guild == 0)
            dstBeing->clearGuilds();
        else
            dstBeing->setGuild(Guild::getGuild(CAST_S16(guild)));
    }
 
    msg.readInt16("emblem");
    dstBeing->setManner(msg.readInt16("manner"));
    const uint32_t opt3 = msg.readInt16("opt3");
    dstBeing->setKarma(msg.readUInt8("karma"));
    // reserving bit for future usage
    dstBeing->setGender(Being::intToGender(
        CAST_U8(msg.readUInt8("gender") & 3)));
 
    if (disguiseId == 0)
    {
        // Set these after the gender, as the sprites may be gender-specific
        dstBeing->updateSprite(SPRITE_BODY,
            weapon,
            std::string());
        dstBeing->setWeaponId(weapon);
        dstBeing->updateSprite(SPRITE_FLOOR, shield, std::string());
        dstBeing->updateSprite(SPRITE_WEAPON, headBottom, std::string());
        dstBeing->updateSprite(SPRITE_HEAD_BOTTOM, headMid, std::string());
        dstBeing->updateSprite(SPRITE_CLOTHES_COLOR, headTop, std::string());
        if (hairStyle == 0)
        {
            dstBeing->updateSprite(SPRITE_HAIR_COLOR,
                0,
                std::string());
        }
        else
        {
            dstBeing->updateSprite(SPRITE_HAIR_COLOR,
                hairStyle * -1,
                ItemDB::get(-hairStyle).getDyeColorsString(hairColor));
        }
        dstBeing->setHairColor(hairColor);
    }
    localPlayer->imitateOutfit(dstBeing, -1);
 
    uint16_t x;
    uint16_t y;
    msg.readCoordinates(x, y, dir, "position");
    dstBeing->setTileCoords(x, y);
    dstBeing->setDirection(dir);
 
    localPlayer->imitateDirection(dstBeing, dir);
 
    const uint16_t gmstatus = msg.readInt16("gm status");
 
    setGm(dstBeing, gmstatus);
 
    applyPlayerAction(msg, dstBeing, msg.readUInt8("action type"));
    const int level = CAST_S32(msg.readUInt8("level"));
    if (level != 0)
        dstBeing->setLevel(level);
 
    msg.readUInt8("unused");
 
    dstBeing->setActionTime(tick_time);
 
    dstBeing->setStatusEffectOpitons(option,
        opt1,
        opt2,
        opt3);
 
    BLOCK_END("BeingRecv::processPlayerMoveUpdate")
}

References actorManager, EAthena::BeingRecv::applyPlayerAction(), beingHandler, BLOCK_END, BLOCK_START, CAST_S16, CAST_S32, CAST_U8, Being::clearGuilds(), Ea::BeingRecv::createBeing(), ActorManager::findBeing(), fromInt, ItemDB::get(), Being::getDirection(), Being::getDirectionDelayed(), GuildManager::getEnableGuildBot(), Guild::getGuild(), Being::getParty(), guild, guildManager, LocalPlayer::imitateDirection(), LocalPlayer::imitateOutfit(), Being::intToGender(), ActorManager::isBlocked(), localPlayer, Actions::msg(), party, Net::BeingHandler::requestNameById(), Being::setActionTime(), Being::setDirection(), Being::setGender(), TmwAthena::setGm(), Being::setGuild(), Being::setHairColor(), Being::setKarma(), Being::setLevel(), Being::setManner(), Being::setParty(), ActorSprite::setStatusEffectOpitons(), Being::setSubtype(), Being::setTileCoords(), Being::setWalkSpeed(), Being::setWeaponId(), SPRITE_BODY, SPRITE_CLOTHES_COLOR, SPRITE_FLOOR, SPRITE_HAIR_COLOR, SPRITE_HEAD_BOTTOM, SPRITE_WEAPON, tick_time, toInt, ActorManager::undelete(), Being::updateSprite(), x, and y.

processPlayerUpdate2()

void TmwAthena::BeingRecv::processPlayerUpdate2

(

Net::MessageIn &

msg

)

Definition at line 386 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processPlayerMoveUpdate")
    if ((actorManager == nullptr) || (localPlayer == nullptr))
    {
        BLOCK_END("BeingRecv::processPlayerMoveUpdate")
        return;
    }
 
    // An update about a player, potentially including movement.
    const BeingId id = msg.readBeingId("account id");
    const int16_t speed = msg.readInt16("speed");
    const uint32_t opt1 = msg.readInt16("opt1");
    const uint32_t opt2 = msg.readInt16("opt2");
    const uint32_t option = msg.readInt16("option");
    const int16_t job = msg.readInt16("job");
    int disguiseId = 0;
    if (toInt(id, int) < 110000000 && job >= 1000)
        disguiseId = job;
 
    Being *dstBeing = actorManager->findBeing(id);
    if (dstBeing == nullptr)
    {
        if (actorManager->isBlocked(id) == true)
        {
            BLOCK_END("BeingRecv::processPlayerMoveUpdate")
            return;
        }
 
        dstBeing = Ea::BeingRecv::createBeing(id, job);
 
        if (dstBeing == nullptr)
        {
            BLOCK_END("BeingRecv::processPlayerMoveUpdate")
            return;
        }
    }
    else if (disguiseId != 0)
    {
        actorManager->undelete(dstBeing);
        beingHandler->requestNameById(id);
    }
 
    uint8_t dir = dstBeing->getDirectionDelayed();
    if (dir != 0U)
    {
        if (dir != dstBeing->getDirection())
            dstBeing->setDirection(dir);
    }
 
    if (Party *const party = localPlayer->getParty())
    {
        if (party->isMember(id))
            dstBeing->setParty(party);
    }
 
    dstBeing->setWalkSpeed(speed);
 
    const uint8_t hairStyle = msg.readUInt8("hair style");
    const uint16_t look = msg.readUInt8("look");
    dstBeing->setSubtype(fromInt(job, BeingTypeId), look);
    const uint16_t weapon = msg.readInt16("weapon");
    const uint16_t shield = msg.readInt16("shield");
    const uint16_t headBottom = msg.readInt16("head bottom");
    const uint16_t headTop = msg.readInt16("head top");
    const uint16_t headMid = msg.readInt16("head mid");
    const ItemColor hairColor = fromInt(
        msg.readUInt8("hair color"), ItemColor);
    msg.readUInt8("unused");
    msg.readInt32("unused");
 
    const int guild = msg.readInt32("guild");
 
    if ((guildManager == nullptr) || !GuildManager::getEnableGuildBot())
    {
        if (guild == 0)
            dstBeing->clearGuilds();
        else
            dstBeing->setGuild(Guild::getGuild(CAST_S16(guild)));
    }
 
    msg.readInt16("emblem");
    dstBeing->setManner(msg.readInt16("manner"));
    const uint32_t opt3 = msg.readInt16("opt3");
    dstBeing->setKarma(msg.readUInt8("karma"));
    // reserving bit for future usage
    dstBeing->setGender(Being::intToGender(
        CAST_U8(msg.readUInt8("gender") & 3)));
 
    if (disguiseId == 0)
    {
        // Set these after the gender, as the sprites may be gender-specific
        dstBeing->updateSprite(SPRITE_BODY,
            weapon,
            std::string());
        dstBeing->setWeaponId(weapon);
        dstBeing->updateSprite(SPRITE_FLOOR, shield, std::string());
        dstBeing->updateSprite(SPRITE_WEAPON, headBottom, std::string());
        dstBeing->updateSprite(SPRITE_HEAD_BOTTOM, headMid, std::string());
        dstBeing->updateSprite(SPRITE_CLOTHES_COLOR, headTop, std::string());
        if (hairStyle == 0)
        {
            dstBeing->updateSprite(SPRITE_HAIR_COLOR,
                0,
                std::string());
        }
        else
        {
            dstBeing->updateSprite(SPRITE_HAIR_COLOR,
                hairStyle * -1,
                ItemDB::get(-hairStyle).getDyeColorsString(hairColor));
        }
        dstBeing->setHairColor(hairColor);
    }
    localPlayer->imitateOutfit(dstBeing, -1);
 
    uint16_t x;
    uint16_t y;
    msg.readCoordinates(x, y, dir, "position");
    dstBeing->setTileCoords(x, y);
    dstBeing->setDirection(dir);
 
    localPlayer->imitateDirection(dstBeing, dir);
 
    const uint16_t gmstatus = msg.readInt16("gm status");
 
    setGm(dstBeing, gmstatus);
 
    applyPlayerAction(msg, dstBeing, msg.readUInt8("action type"));
    const int level = CAST_S32(msg.readUInt8("level"));
    if (level != 0)
        dstBeing->setLevel(level);
 
    dstBeing->setActionTime(tick_time);
    dstBeing->setStatusEffectOpitons(option,
        opt1,
        opt2,
        opt3);
 
    BLOCK_END("BeingRecv::processPlayerMoveUpdate")
}

References actorManager, EAthena::BeingRecv::applyPlayerAction(), beingHandler, BLOCK_END, BLOCK_START, CAST_S16, CAST_S32, CAST_U8, Being::clearGuilds(), Ea::BeingRecv::createBeing(), ActorManager::findBeing(), fromInt, ItemDB::get(), Being::getDirection(), Being::getDirectionDelayed(), GuildManager::getEnableGuildBot(), Guild::getGuild(), Being::getParty(), guild, guildManager, LocalPlayer::imitateDirection(), LocalPlayer::imitateOutfit(), Being::intToGender(), ActorManager::isBlocked(), localPlayer, Actions::msg(), party, Net::BeingHandler::requestNameById(), Being::setActionTime(), Being::setDirection(), Being::setGender(), TmwAthena::setGm(), Being::setGuild(), Being::setHairColor(), Being::setKarma(), Being::setLevel(), Being::setManner(), Being::setParty(), ActorSprite::setStatusEffectOpitons(), Being::setSubtype(), Being::setTileCoords(), Being::setWalkSpeed(), Being::setWeaponId(), SPRITE_BODY, SPRITE_CLOTHES_COLOR, SPRITE_FLOOR, SPRITE_HAIR_COLOR, SPRITE_HEAD_BOTTOM, SPRITE_WEAPON, tick_time, toInt, ActorManager::undelete(), Being::updateSprite(), x, and y.

processPvpSet()

void TmwAthena::BeingRecv::processPvpSet

(

Net::MessageIn &

msg

)

Definition at line 1416 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processPvpSet")
    const BeingId id = msg.readBeingId("being id");
    const int rank = msg.readInt32("rank");
    int teamId = 0;
    teamId = msg.readInt32("team");
    if (actorManager != nullptr)
    {
        Being *const dstBeing = actorManager->findBeing(id);
        if (dstBeing != nullptr)
        {
            dstBeing->setPvpRank(rank);
            dstBeing->setTeamId(CAST_U16(teamId));
            dstBeing->addToCache();
        }
    }
    BLOCK_END("BeingRecv::processPvpSet")
}

References actorManager, Being::addToCache(), BLOCK_END, BLOCK_START, CAST_U16, ActorManager::findBeing(), Actions::msg(), Being::setPvpRank(), and Being::setTeamId().

processSkillCastCancel()

void TmwAthena::BeingRecv::processSkillCastCancel

(

Net::MessageIn &

msg

)

Definition at line 1386 of file beingrecv.cpp.

{
    msg.readInt32("skill id");
}

References Actions::msg().

processSkillCasting()

void TmwAthena::BeingRecv::processSkillCasting

(

Net::MessageIn &

msg

)

Definition at line 1135 of file beingrecv.cpp.

{
    msg.readInt32("src id");
    msg.readInt32("dst id");
    msg.readInt16("dst x");
    msg.readInt16("dst y");
    msg.readInt16("skill num");
    msg.readInt32("skill get p1");
    msg.readInt32("cast time");
}

References Actions::msg().

processSkillDamage()

void TmwAthena::BeingRecv::processSkillDamage

(

Net::MessageIn &

msg

)

Definition at line 1468 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processSkillDamage")
    if (actorManager == nullptr)
    {
        BLOCK_END("BeingRecv::processSkillDamage")
        return;
    }
 
    const int id = msg.readInt16("skill id");
    Being *const srcBeing = actorManager->findBeing(
        msg.readBeingId("src being id"));
    Being *const dstBeing = actorManager->findBeing(
        msg.readBeingId("dst being id"));
    msg.readInt32("tick");
    msg.readInt32("src speed");
    msg.readInt32("dst speed");
    const int param1 = msg.readInt32("damage");
    const int level = msg.readInt16("skill level");
    msg.readInt16("div");
    msg.readUInt8("skill hit/type?");
    if (srcBeing != nullptr)
        srcBeing->handleSkill(dstBeing, param1, id, level);
    if (dstBeing != nullptr)
        dstBeing->takeDamage(srcBeing, param1, AttackType::SKILL, id, level);
    BLOCK_END("BeingRecv::processSkillDamage")
}

References actorManager, BLOCK_END, BLOCK_START, ActorManager::findBeing(), Being::handleSkill(), Actions::msg(), AttackType::SKILL, and Being::takeDamage().

setServerGender()

void TmwAthena::BeingRecv::setServerGender	(	Being *const	being,
		const uint8_t	gender
	)

Definition at line 1496 of file beingrecv.cpp.

{
    if (being == nullptr)
        return;
    switch (gender)
    {
        case 2:
            being->setGender(Gender::FEMALE);
            break;
        case 3:
            being->setGender(Gender::MALE);
            break;
        default:
            being->setGender(Gender::UNSPECIFIED);
            break;
    }
}

References Gender::FEMALE, Gender::MALE, Being::setGender(), and Gender::UNSPECIFIED.

Referenced by processBeingMove(), and processBeingVisible().