EAthena::BeingRecv Namespace Reference

Functions
void	processBeingChangeLook2 (Net::MessageIn &msg)
void	processBeingChangeLookCards (Net::MessageIn &msg)
void	processBeingVisible (Net::MessageIn &msg)
void	processBeingMove (Net::MessageIn &msg)
void	processBeingSpawn (Net::MessageIn &msg)
void	processMapTypeProperty (Net::MessageIn &msg)
void	processMapType (Net::MessageIn &msg)
void	processSkillCasting (Net::MessageIn &msg)
void	processSkillCasting2 (Net::MessageIn &msg)
void	processSkillCasting3 (Net::MessageIn &msg)
void	processSkillCastingEvol (Net::MessageIn &msg)
void	processBeingStatusChange (Net::MessageIn &msg)
void	processBeingMove2 (Net::MessageIn &msg)
void	processBeingAction2 (Net::MessageIn &msg)
void	processMonsterHp (Net::MessageIn &msg)
void	processBeingHp (Net::MessageIn &msg)
void	processSkillAutoCast (Net::MessageIn &msg)
void	processRanksList1 (Net::MessageIn &msg)
void	processRanksList2 (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, const int *const cards)
void	processBeingSpecialEffect (Net::MessageIn &msg)
void	processBeingSpecialEffectNum (Net::MessageIn &msg)
void	processBeingHatEffects (Net::MessageIn &msg)
void	processBeingRemoveSpecialEffect (Net::MessageIn &msg)
void	processBeingSoundEffect (Net::MessageIn &msg)
void	processSkillGroundNoDamage (Net::MessageIn &msg)
void	processSkillEntry (Net::MessageIn &msg)
void	processPlayerStatusChange (Net::MessageIn &msg)
void	processBeingResurrect (Net::MessageIn &msg)
void	processNameResponseTitle (Net::MessageIn &msg)
void	processPlayerGuilPartyInfo (Net::MessageIn &msg)
void	processPlayerGuilPartyInfo2 (Net::MessageIn &msg)
void	processBeingRemoveSkill (Net::MessageIn &msg)
void	processBeingFakeName (Net::MessageIn &msg)
void	processBeingStatUpdate1 (Net::MessageIn &msg)
void	processPlayerStatusChange2 (Net::MessageIn &msg)
void	processBeingSelfEffect (Net::MessageIn &msg)
void	processMobInfo (Net::MessageIn &msg)
void	processBeingAttrs (Net::MessageIn &msg)
void	processMonsterInfo (Net::MessageIn &msg)
void	processClassChange (Net::MessageIn &msg)
void	processSpiritBalls (Net::MessageIn &msg)
void	processBladeStop (Net::MessageIn &msg)
void	processComboDelay (Net::MessageIn &msg)
void	processWddingEffect (Net::MessageIn &msg)
void	processBeingSlide (Net::MessageIn &msg)
void	processStarsKill (Net::MessageIn &msg)
void	processBlacksmithRanksList (Net::MessageIn &msg)
void	processAlchemistRanksList (Net::MessageIn &msg)
void	processTaekwonRanksList (Net::MessageIn &msg)
void	processPkRanksList (Net::MessageIn &msg)
void	processGladiatorFeelRequest (Net::MessageIn &msg)
void	processBossMapInfo (Net::MessageIn &msg)
void	processBeingFont (Net::MessageIn &msg)
void	processBeingMilleniumShield (Net::MessageIn &msg)
void	processBeingCharm (Net::MessageIn &msg)
void	processBeingViewEquipment (Net::MessageIn &msg)
void	processBeingViewEquipment2 (Net::MessageIn &msg)
void	processPvpSet (Net::MessageIn &msg)
void	processNameResponse2 (Net::MessageIn &msg)
void	processSkillCancel (Net::MessageIn &msg)
void	processSolveCharName (Net::MessageIn &msg)
void	processGraffiti (Net::MessageIn &msg)
void	processSkillDamage (Net::MessageIn &msg)
void	processNavigateTo (Net::MessageIn &msg)
Being *	createBeing2 (Net::MessageIn &msg, const BeingId id, const int32_t job, const BeingTypeT beingType)
void	applyPlayerAction (Net::MessageIn &msg, Being *const being, const uint8_t type)
void	processSkillCastingContinue (Net::MessageIn &msg, const BeingId srcId, const BeingId dstId, const int dstX, const int dstY, const int skillId, const int skillLevel, const int range, const SkillType2::SkillType2 inf2, const int castTime)

Function Documentation

applyPlayerAction()

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

Definition at line 2397 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.

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

createBeing2()

Being * EAthena::BeingRecv::createBeing2	(	Net::MessageIn &	msg,
		const BeingId	id,
		const int32_t	job,
		const BeingTypeT	beingType
	)

Definition at line 2236 of file beingrecv.cpp.

{
    if (actorManager == nullptr)
        return nullptr;
 
    ActorTypeT type = ActorType::Unknown;
    switch (beingType)
    {
        case BeingType::PC:
            type = ActorType::Player;
            break;
        case BeingType::NPC:
        case BeingType::NPC_EVENT:
            type = ActorType::Npc;
            break;
        case BeingType::MONSTER:
            type = ActorType::Monster;
            break;
        case BeingType::MERSOL:
            type = ActorType::Mercenary;
            break;
        case BeingType::PET:
            type = ActorType::Pet;
            break;
        case BeingType::HOMUN:
            type = ActorType::Homunculus;
            break;
        case BeingType::SKILL:
            type = ActorType::SkillUnit;
            break;
        case BeingType::ELEMENTAL:
            type = ActorType::Elemental;
            break;
        case BeingType::ITEM:
            logger->log("not supported object type: %d, job: %d",
                CAST_S32(beingType), CAST_S32(job));
            break;
        case BeingType::CHAT:
        default:
            UNIMPLEMENTEDPACKETFIELD(CAST_S32(beingType));
            type = ActorType::Monster;
            logger->log("not supported object type: %d, job: %d",
                CAST_S32(beingType), CAST_S32(job));
            break;
    }
    if (job == 45 && beingType == BeingType::NPC_EVENT)
        type = ActorType::Portal;
 
    Being *const being = actorManager->createBeing(
        id, type, fromInt(job, BeingTypeId));
    if (beingType == BeingType::MERSOL)
    {
        const MercenaryInfo *const info = PlayerInfo::getMercenary();
        if ((info != nullptr) && info->id == id)
            PlayerInfo::setMercenaryBeing(being);
    }
    else if (beingType == BeingType::PET)
    {
        if (PlayerInfo::getPetBeingId() == id)
            PlayerInfo::setPetBeing(being);
    }
    return being;
}

References actorManager, CAST_S32, BeingType::CHAT, ActorManager::createBeing(), ActorType::Elemental, BeingType::ELEMENTAL, fromInt, PlayerInfo::getMercenary(), PlayerInfo::getPetBeingId(), BeingType::HOMUN, ActorType::Homunculus, Actions::info(), BeingType::ITEM, Logger::log(), logger, ActorType::Mercenary, BeingType::MERSOL, ActorType::Monster, BeingType::MONSTER, ActorType::Npc, BeingType::NPC, BeingType::NPC_EVENT, BeingType::PC, ActorType::Pet, BeingType::PET, ActorType::Player, ActorType::Portal, PlayerInfo::setMercenaryBeing(), PlayerInfo::setPetBeing(), BeingType::SKILL, ActorType::SkillUnit, UNIMPLEMENTEDPACKETFIELD, and ActorType::Unknown.

Referenced by processBeingFakeName(), processBeingMove(), processBeingSpawn(), processBeingVisible(), processGraffiti(), and processSkillEntry().

processAlchemistRanksList()

void EAthena::BeingRecv::processAlchemistRanksList

(

Net::MessageIn &

msg

)

Definition at line 1433 of file beingrecv.cpp.

{
    UNIMPLEMENTEDPACKET;
    // +++ here need window with rank tables.
    for (int f = 0; f < 10; f ++)
        msg.readString(24, "name");
    for (int f = 0; f < 10; f ++)
        msg.readInt32("points");
}

References Actions::msg(), and UNIMPLEMENTEDPACKET.

processBeingAction2()

void EAthena::BeingRecv::processBeingAction2

(

Net::MessageIn &

msg

)

Definition at line 1238 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processBeingAction2")
    if (actorManager == nullptr)
    {
        BLOCK_END("BeingRecv::processBeingAction2")
        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");
    int param1;
    if (msg.getVersion() >= 20071113)
        param1 = msg.readInt32("damage");
    else
        param1 = msg.readInt16("damage");
    if (msg.getVersion() >= 20131223)
        msg.readUInt8("is sp damaged");
    msg.readInt16("count");
    const AttackTypeT type = static_cast<AttackTypeT>(
        msg.readUInt8("action"));
    if (msg.getVersion() >= 20071113)
        msg.readInt32("left damage");
    else
        msg.readInt16("left damage");
 
    switch (type)
    {
        case AttackType::HIT:  // Damage
        case AttackType::CRITICAL:  // Critical Damage
        case AttackType::MULTI:  // Critical Damage
        case AttackType::MULTI_REFLECT:
        case AttackType::REFLECT:  // Reflected Damage
        case AttackType::FLEE:  // Lucky Dodge
        case AttackType::SPLASH:
        case AttackType::SKILL:
        case AttackType::REPEATE:
            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:
        case AttackType::TOUCH_SKILL:
            break;
 
        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::MISS:
        case AttackType::SKILLMISS:
            UNIMPLEMENTEDPACKETFIELD(CAST_S32(type));
            break;
    }
    BLOCK_END("BeingRecv::processBeingAction2")
}

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.

processBeingAttrs()

void EAthena::BeingRecv::processBeingAttrs

(

Net::MessageIn &

msg

)

Definition at line 1927 of file beingrecv.cpp.

{
    if (actorManager == nullptr)
        return;
    const int len = msg.readInt16("len");
    if (len < 14)
        return;
 
    Being *const dstBeing = actorManager->findBeing(
        msg.readBeingId("player id"));
    const int groupId = msg.readInt32("group id");
    uint16_t mount = 0;
    mount = msg.readInt16("mount");
    int language = -1;
    if (len > 14)
        language = msg.readInt16("language");
    int clanId = 0;
    if (len > 16)
        clanId = msg.readInt32("clan id");
    if (dstBeing != nullptr)
    {
        if (dstBeing != localPlayer)
        {
            dstBeing->setGroupId(groupId);
        }
        dstBeing->setHorse(mount);
        dstBeing->setLanguageId(language);
        if (clanId != 0)
        {
            const ClanInfo *const info = ClanDb::get(clanId);
            if (info == nullptr)
                dstBeing->setClanName(std::string());
            else
                dstBeing->setClanName(info->name);
        }
        else
        {
            dstBeing->setClanName(std::string());
        }
        if (dstBeing == localPlayer)
            PlayerInfo::setServerLanguage(language);
    }
}

References actorManager, ActorManager::findBeing(), ClanDb::get(), Actions::info(), localPlayer, Actions::msg(), Being::setClanName(), Being::setGroupId(), Being::setHorse(), Being::setLanguageId(), and PlayerInfo::setServerLanguage().

processBeingChangeDirection()

void EAthena::BeingRecv::processBeingChangeDirection

(

Net::MessageIn &

msg

)

Definition at line 1463 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"));
 
    msg.readInt16("head direction");
 
    const uint8_t dir = Net::MessageIn::fromServerDirection(
        CAST_U8(msg.readUInt8("player direction") & 0x0FU));
 
    if (dstBeing == nullptr)
    {
        BLOCK_END("BeingRecv::processBeingChangeDirection")
        return;
    }
 
    dstBeing->setDirection(dir);
    if (localPlayer != nullptr)
        localPlayer->imitateDirection(dstBeing, dir);
    BLOCK_END("BeingRecv::processBeingChangeDirection")
}

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

processBeingChangeLook2()

void EAthena::BeingRecv::processBeingChangeLook2

(

Net::MessageIn &

msg

)

Definition at line 200 of file beingrecv.cpp.

{
    if (actorManager == nullptr)
        return;
 
    Being *const dstBeing = actorManager->findBeing(
        msg.readBeingId("being id"));
    const uint8_t type = msg.readUInt8("type");
 
    const int id = msg.readItemId("id1");
    unsigned int id2 = msg.readItemId("id2");
    if (type != 2)
        id2 = 1;
 
    if (localPlayer == nullptr || dstBeing == nullptr)
        return;
 
    processBeingChangeLookContinue(msg, dstBeing, type, id, id2, nullptr);
}

References actorManager, ActorManager::findBeing(), localPlayer, Actions::msg(), and processBeingChangeLookContinue().

processBeingChangeLookCards()

void EAthena::BeingRecv::processBeingChangeLookCards

(

Net::MessageIn &

msg

)

Definition at line 220 of file beingrecv.cpp.

{
    Being *dstBeing = nullptr;
    int cards[maxCards];
 
    if (actorManager == nullptr)
    {   // here can be look from char server
        Net::Characters &chars = Net::CharServerHandler::mCharacters;
        const BeingId id = msg.readBeingId("being id");
 
        FOR_EACH (Net::Characters::iterator, it, chars)
        {
            const Net::Character *const character = *it;
            if (character->dummy != nullptr &&
                character->dummy->getId() == id)
            {
                dstBeing = character->dummy;
                break;
            }
        }
    }
    else
    {
        dstBeing = actorManager->findBeing(
            msg.readBeingId("being id"));
    }
 
    const uint8_t type = msg.readUInt8("type");
 
    const int id = msg.readInt16("id1");
    unsigned int id2 = msg.readInt16("id2");
    if (type != 2)
        id2 = 1;
 
    for (int f = 0; f < maxCards; f ++)
        cards[f] = msg.readUInt16("card");  // +++ probably need use int32
 
    if (dstBeing == nullptr)
        return;
 
    processBeingChangeLookContinue(msg, dstBeing, type, id, id2, &cards[0]);
}

References actorManager, Net::Character::dummy, ActorManager::findBeing(), FOR_EACH, ActorSprite::getId(), maxCards, Net::CharServerHandler::mCharacters, Actions::msg(), and processBeingChangeLookContinue().

processBeingChangeLookContinue()

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

Definition at line 263 of file beingrecv.cpp.

{
    if (dstBeing->getType() == ActorType::Player)
        dstBeing->setOtherTime();
 
    switch (type)
    {
        // here should be used SPRITE_* constants
        // but for now they conflicting with sprites
        // SPRITE_* is same with server LOOK_*
        case 0:  // change race
            dstBeing->setSubtype(fromInt(id, BeingTypeId),
                dstBeing->getLook());
            break;
        case 1:  // eAthena LOOK_HAIR
            dstBeing->setHairColor(fromInt(id, ItemColor));
            dstBeing->setHairColorSpriteID(SPRITE_HAIR_COLOR,
                id * -1);
            break;
        case 2:  // LOOK_WEAPON Weapon ID in id, Shield ID in id2
            dstBeing->setSpriteCards(SPRITE_BODY,
                id,
                CardsList(cards));
            dstBeing->setWeaponId(id);
            dstBeing->setSpriteId(SPRITE_FLOOR,
                id2);
            if (localPlayer != nullptr)
                localPlayer->imitateOutfit(dstBeing, SPRITE_FLOOR);
            break;
        case 3:  // LOOK_HEAD_BOTTOM
            dstBeing->setSpriteCards(SPRITE_WEAPON,
                id,
                CardsList(cards));
            if (localPlayer != nullptr)
                localPlayer->imitateOutfit(dstBeing, SPRITE_WEAPON);
            break;
        case 4:  // LOOK_HEAD_TOP Change upper headgear for eAthena, hat for us
            dstBeing->setSpriteCards(SPRITE_CLOTHES_COLOR,
                id,
                CardsList(cards));
            if (localPlayer != nullptr)
                localPlayer->imitateOutfit(dstBeing, SPRITE_CLOTHES_COLOR);
            break;
        case 5:  // LOOK_HEAD_MID Change middle headgear for eathena,
                 // armor for us
            dstBeing->setSpriteCards(SPRITE_HEAD_BOTTOM,
                id,
                CardsList(cards));
            if (localPlayer != nullptr)
                localPlayer->imitateOutfit(dstBeing, SPRITE_HEAD_BOTTOM);
            break;
        case 6:  // eAthena LOOK_HAIR_COLOR
            dstBeing->setHairColor(fromInt(id, ItemColor));
            dstBeing->setSpriteColor(SPRITE_HAIR_COLOR,
                ItemDB::get(dstBeing->getSpriteID(
                SPRITE_HAIR_COLOR)).getDyeColorsString(
                fromInt(id, ItemColor)));
            break;
        case 7:  // Clothes color. Now used as look
            dstBeing->setLook(CAST_U8(id));
            break;
        case 8:  // eAthena LOOK_SHIELD
            dstBeing->setSpriteCards(SPRITE_FLOOR,
                id,
                CardsList(cards));
            if (localPlayer != nullptr)
                localPlayer->imitateOutfit(dstBeing, SPRITE_FLOOR);
            break;
        case 9:  // eAthena LOOK_SHOES
            dstBeing->setSpriteCards(SPRITE_HAIR,
                id,
                CardsList(cards));
            if (localPlayer != nullptr)
                localPlayer->imitateOutfit(dstBeing, SPRITE_HAIR);
            break;
        case 10:  // LOOK_GLOVES
            dstBeing->setSpriteCards(SPRITE_SHOES,
                id,
                CardsList(cards));
            if (localPlayer != nullptr)
                localPlayer->imitateOutfit(dstBeing, SPRITE_SHOES);
            break;
        case 11:  // LOOK_FLOOR
            dstBeing->setSpriteCards(SPRITE_SHIELD,
                id,
                CardsList(cards));
            if (localPlayer != nullptr)
                localPlayer->imitateOutfit(dstBeing, SPRITE_SHIELD);
            break;
        case 12:  // LOOK_ROBE
            dstBeing->setSpriteCards(SPRITE_HEAD_TOP,
                id,
                CardsList(cards));
            if (localPlayer != nullptr)
                localPlayer->imitateOutfit(dstBeing, SPRITE_HEAD_TOP);
            break;
        case 13:  // COSTUME_HEAD_TOP
            dstBeing->setSpriteCards(SPRITE_HEAD_MID,
                id,
                CardsList(cards));
            if (localPlayer != nullptr)
                localPlayer->imitateOutfit(dstBeing, SPRITE_HEAD_MID);
            break;
        case 14:  // COSTUME_HEAD_MID
            dstBeing->setSpriteCards(SPRITE_ROBE,
                id,
                CardsList(cards));
            if (localPlayer != nullptr)
                localPlayer->imitateOutfit(dstBeing, SPRITE_ROBE);
            break;
        case 15:  // COSTUME_HEAD_LOW
            dstBeing->setSpriteCards(SPRITE_EVOL2,
                id,
                CardsList(cards));
            if (localPlayer != nullptr)
                localPlayer->imitateOutfit(dstBeing, SPRITE_EVOL2);
            break;
        case 16:  // COSTUME_GARMENT
            dstBeing->setSpriteCards(SPRITE_EVOL3,
                id,
                CardsList(cards));
            if (localPlayer != nullptr)
                localPlayer->imitateOutfit(dstBeing, SPRITE_EVOL3);
            break;
        case 17:  // ARMOR
            dstBeing->setSpriteCards(SPRITE_EVOL4,
                id,
                CardsList(cards));
            if (localPlayer != nullptr)
                localPlayer->imitateOutfit(dstBeing, SPRITE_EVOL4);
            break;
        case 18:
            dstBeing->setSpriteCards(SPRITE_EVOL5,
                id,
                CardsList(cards));
            if (localPlayer != nullptr)
                localPlayer->imitateOutfit(dstBeing, SPRITE_EVOL5);
            break;
        case 19:
            dstBeing->setSpriteCards(SPRITE_EVOL6,
                id,
                CardsList(cards));
            if (localPlayer != nullptr)
                localPlayer->imitateOutfit(dstBeing, SPRITE_EVOL6);
            break;
        default:
            UNIMPLEMENTEDPACKETFIELD(type);
            break;
    }
}

References CAST_U8, fromInt, ItemDB::get(), ItemInfo::getDyeColorsString(), Being::getLook(), Being::getSpriteID(), Being::getType(), LocalPlayer::imitateOutfit(), localPlayer, ActorType::Player, Being::setHairColor(), Being::setHairColorSpriteID(), Being::setLook(), Being::setOtherTime(), Being::setSpriteCards(), Being::setSpriteColor(), Being::setSpriteId(), Being::setSubtype(), Being::setWeaponId(), SPRITE_BODY, SPRITE_CLOTHES_COLOR, SPRITE_EVOL2, SPRITE_EVOL3, SPRITE_EVOL4, SPRITE_EVOL5, SPRITE_EVOL6, 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.

Referenced by TmwAthena::BeingRecv::processBeingChangeLook(), processBeingChangeLook2(), TmwAthena::BeingRecv::processBeingChangeLook2(), and processBeingChangeLookCards().

processBeingCharm()

void EAthena::BeingRecv::processBeingCharm

(

Net::MessageIn &

msg

)

Definition at line 2099 of file beingrecv.cpp.

{
    UNIMPLEMENTEDPACKET;
 
    msg.readBeingId("account id");
    msg.readInt16("charm type");
    msg.readInt16("charm count");
}

References Actions::msg(), and UNIMPLEMENTEDPACKET.

processBeingFakeName()

void EAthena::BeingRecv::processBeingFakeName

(

Net::MessageIn &

msg

)

Definition at line 1831 of file beingrecv.cpp.

{
    uint16_t x;
    uint16_t y;
    uint8_t dir;
    if (msg.getVersion() < 20071106)
    {
        msg.readBeingId("npc id");
        msg.skip(8, "unused");
        msg.readInt16("class?");  // 111
        msg.skip(30, "unused");
        msg.readCoordinates(x, y, dir, "position");
        msg.readUInt8("sx");
        msg.readUInt8("sy");
        msg.skip(3, "unused");
        return;
    }
    const BeingTypeT type = static_cast<BeingTypeT>(
        msg.readUInt8("object type"));
    const BeingId id = msg.readBeingId("npc id");
    msg.skip(8, "unused");
    const uint16_t job = msg.readInt16("class?");  // 111
    msg.skip(30, "unused");
    msg.readCoordinates(x, y, dir, "position");
    msg.readUInt8("sx");
    msg.readUInt8("sy");
    msg.skip(3, "unused");
 
    Being *const dstBeing = createBeing2(msg, id, job, type);
    if (dstBeing == nullptr)
        return;
    dstBeing->setSubtype(fromInt(job, BeingTypeId), 0);
    dstBeing->setTileCoords(x, y);
    dstBeing->setDirection(dir);
}

References createBeing2(), fromInt, Actions::msg(), Being::setDirection(), Being::setSubtype(), Being::setTileCoords(), x, and y.

processBeingFont()

void EAthena::BeingRecv::processBeingFont

(

Net::MessageIn &

msg

)

Definition at line 2082 of file beingrecv.cpp.

{
    UNIMPLEMENTEDPACKET;
 
    msg.readBeingId("account id");
    msg.readInt16("font");
}

References Actions::msg(), and UNIMPLEMENTEDPACKET.

processBeingHatEffects()

void EAthena::BeingRecv::processBeingHatEffects

(

Net::MessageIn &

msg

)

Definition at line 1525 of file beingrecv.cpp.

{
    // +++ add new type of permanent effects?
    const int cnt = (msg.readInt16("len") - 9) / 2;
    if (cnt > 0)
    {
        UNIMPLEMENTEDPACKET;
    }
    msg.readBeingId("being id");
    msg.readUInt8("enable");
    for (int f = 0; f < cnt; f ++)
        msg.readInt16("hat effect");
}

References Actions::msg(), and UNIMPLEMENTEDPACKET.

processBeingHp()

void EAthena::BeingRecv::processBeingHp

(

Net::MessageIn &

msg

)

Definition at line 1339 of file beingrecv.cpp.

{
    if (actorManager == nullptr)
        return;
    Being *const dstBeing = actorManager->findBeing(
        msg.readBeingId("being id"));
    int hp;
    int maxHP;
    if (msg.getVersion() >= 20100126)
    {
        hp = msg.readInt32("hp");
        maxHP = msg.readInt32("max hp");
    }
    else
    {
        hp = msg.readInt16("hp");
        maxHP = msg.readInt16("max hp");
    }
    if (dstBeing != nullptr)
    {
        dstBeing->setHP(hp);
        dstBeing->setMaxHP(maxHP);
    }
}

References actorManager, ActorManager::findBeing(), Actions::msg(), Being::setHP(), and Being::setMaxHP().

processBeingMilleniumShield()

void EAthena::BeingRecv::processBeingMilleniumShield

(

Net::MessageIn &

msg

)

Definition at line 2090 of file beingrecv.cpp.

{
    UNIMPLEMENTEDPACKET;
 
    msg.readBeingId("account id");
    msg.readInt16("shields");
    msg.readInt16("unused");
}

References Actions::msg(), and UNIMPLEMENTEDPACKET.

processBeingMove()

void EAthena::BeingRecv::processBeingMove

(

Net::MessageIn &

msg

)

Definition at line 606 of file beingrecv.cpp.

{
    if (actorManager == nullptr)
        return;
 
    if (msg.getVersion() >= 20091103)
        msg.readInt16("len");
    BeingTypeT type;
    if (msg.getVersion() >= 20071106)
    {
        type = static_cast<BeingTypeT>(
            msg.readUInt8("object type"));
    }
    else
    {
        // need detect type based on id
        type = BeingType::MONSTER;
    }
 
    // Information about a being in range
    const BeingId id = msg.readBeingId("being id");
    if (msg.getVersion() >= 20131223)
        msg.readBeingId("char id");
    BeingId spawnId;
    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");
    // probably wrong effect usage
    const uint32_t opt2 = msg.readInt16("opt2");
    uint32_t option;
    if (msg.getVersion() >= 7)
        option = msg.readInt32("option");
    else
        option = msg.readInt16("option");
    const int16_t job = msg.readInt16("class");
 
    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)
    {
        if (actorManager->isBlocked(id) == true)
            return;
 
        dstBeing = createBeing2(msg, id, job, type);
        if (dstBeing == nullptr)
            return;
    }
    else
    {
        // undeleting marked for deletion being
        if (dstBeing->getType() == ActorType::Npc)
            actorManager->undelete(dstBeing);
    }
 
    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;
 
    dstBeing->setWalkSpeed(speed);
    dstBeing->setSubtype(fromInt(job, BeingTypeId), 0);
    if (dstBeing->getType() == ActorType::Monster && (localPlayer != nullptr))
        localPlayer->checkNewName(dstBeing);
 
    const int hairStyle = msg.readInt16("hair style");
    uint32_t weapon;
    if (msg.getVersion() >= 7)
    {
        weapon = msg.readItemId("weapon");
        msg.readItemId("shield");
    }
    else
    {
        weapon = CAST_U32(msg.readInt16("weapon"));
    }
    const uint16_t headBottom = msg.readInt16("head bottom");
    msg.readInt32("tick");
    if (msg.getVersion() < 7)
        msg.readInt16("shield");
    const uint16_t headTop = msg.readInt16("head top");
    const uint16_t headMid = msg.readInt16("head mid");
    const ItemColor hairColor = fromInt(
        msg.readInt16("hair color"), ItemColor);
    const uint16_t shoes = msg.readInt16("shoes or clothes color?");
 
    const uint16_t gloves = msg.readInt16("head dir / gloves");
    // may be use robe as gloves?
    if (msg.getVersion() >= 20101124)
        msg.readInt16("robe");
    msg.readInt32("guild id");
    msg.readInt16("guild emblem");
    dstBeing->setManner(msg.readInt16("manner"));
    uint32_t opt3;
    if (msg.getVersion() >= 7)
        opt3 = msg.readInt32("opt3");
    else
        opt3 = msg.readInt16("opt3");
    dstBeing->setKarma(msg.readUInt8("karma"));
    const uint8_t gender = CAST_U8(msg.readUInt8("gender") & 3);
 
    setBasicFields(dstBeing,
        gender,
        hairStyle,
        hairColor,
        weapon,
        headBottom,
        headMid,
        headTop,
        shoes,
        gloves,
        !serverFeatures->haveMove3());
 
    uint16_t srcX;
    uint16_t srcY;
    uint16_t dstX;
    uint16_t dstY;
    msg.readCoordinatePair(srcX, srcY, dstX, dstY, "move path");
    msg.readUInt8("(sx<<4) | (sy&0x0f)");
    msg.readInt8("xs");
    msg.readInt8("ys");
    dstBeing->setAction(BeingAction::STAND, 0);
    dstBeing->setTileCoords(srcX, srcY);
    if (localPlayer != nullptr)
        localPlayer->followMoveTo(dstBeing, srcX, srcY, dstX, dstY);
    if (serverFeatures->haveMove3())
        dstBeing->setCachedDestination(dstX, dstY);
    else
        dstBeing->setDestination(dstX, dstY);
 
    // because server don't send direction in move packet, we fixing it
 
    uint8_t d = 0;
    if (localPlayer != nullptr &&
        srcX == dstX &&
        srcY == dstY)
    {   // if player did one step from invisible area to visible,
        // move path is broken
        int x2 = localPlayer->getTileX();
        int y2 = localPlayer->getTileY();
        if (abs(x2 - srcX) > abs(y2 - srcY))
            y2 = srcY;
        else
            x2 = srcX;
        d = dstBeing->calcDirection(x2, y2);
    }
    else
    {
        d = dstBeing->calcDirection(dstX, dstY);
    }
    if ((d != 0U) && dstBeing->getDirection() != d)
        dstBeing->setDirection(d);
 
    const int level = CAST_S32(msg.readInt16("level"));
    if (level != 0)
        dstBeing->setLevel(level);
    if (msg.getVersion() >= 20080102)
        msg.readInt16("font");
    if (msg.getVersion() >= 20120221)
    {
        const int maxHP = msg.readInt32("max hp");
        const int hp = msg.readInt32("hp");
        dstBeing->setMaxHP(maxHP);
        dstBeing->setHP(hp);
        msg.readInt8("is boss");
    }
    if (msg.getVersion() >= 20150513)
    {
        msg.readInt16("body2");
    }
    if (msg.getVersion() >= 20131223)
    {
        msg.readString(24, "name");
    }
 
    dstBeing->setStatusEffectOpitons(option,
        opt1,
        opt2,
        opt3);
}

References actorManager, BeingId_zero, Being::calcDirection(), CAST_S32, CAST_U32, CAST_U8, LocalPlayer::checkNewName(), createBeing2(), ActorManager::destroy(), ActorManager::erase(), ActorManager::findBeing(), LocalPlayer::followMoveTo(), fromInt, Being::getDirection(), Being::getTileX(), Being::getTileY(), Being::getType(), Net::ServerFeatures::haveMove3(), Being::isAlive(), ActorManager::isBlocked(), localPlayer, ActorType::Monster, BeingType::MONSTER, Actions::msg(), Ea::BeingRecv::mSpawnId, ActorType::Npc, ActorType::Player, serverFeatures, Being::setAction(), EAthena::setBasicFields(), Being::setCachedDestination(), Being::setDestination(), Being::setDirection(), Being::setHP(), Being::setKarma(), Being::setLevel(), Being::setManner(), Being::setMaxHP(), Being::setMoveTime(), ActorSprite::setStatusEffectOpitons(), Being::setSubtype(), Being::setTileCoords(), Being::setWalkSpeed(), BeingAction::SPAWN, BeingAction::STAND, and ActorManager::undelete().

processBeingMove2()

void EAthena::BeingRecv::processBeingMove2

(

Net::MessageIn &

msg

)

Definition at line 1189 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"));
 
    uint16_t srcX;
    uint16_t srcY;
    uint16_t dstX;
    uint16_t dstY;
    msg.readCoordinatePair(srcX, srcY, dstX, dstY, "move path");
    msg.readUInt8("(sx<<4) | (sy&0x0f)");
    msg.readInt32("tick");
 
    /*
      * 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;
    }
 
    dstBeing->setTileCoords(srcX, srcY);
    if (localPlayer != nullptr)
        localPlayer->followMoveTo(dstBeing, srcX, srcY, dstX, dstY);
    if (serverFeatures->haveMove3())
        dstBeing->setCachedDestination(dstX, dstY);
    else
        dstBeing->setDestination(dstX, dstY);
    if (dstBeing->getType() == ActorType::Player)
        dstBeing->setMoveTime();
    BLOCK_END("BeingRecv::processBeingMove2")
}

References actorManager, BLOCK_END, BLOCK_START, ActorManager::findBeing(), LocalPlayer::followMoveTo(), Being::getType(), Net::ServerFeatures::haveMove3(), localPlayer, Actions::msg(), ActorType::Player, serverFeatures, Being::setCachedDestination(), Being::setDestination(), Being::setMoveTime(), and Being::setTileCoords().

processBeingRemoveSkill()

void EAthena::BeingRecv::processBeingRemoveSkill

(

Net::MessageIn &

msg

)

Definition at line 1820 of file beingrecv.cpp.

{
    const BeingId id = msg.readBeingId("skill unit id");
    if (actorManager == nullptr)
        return;
    Being *const dstBeing = actorManager->findBeing(id);
    if (dstBeing == nullptr)
        return;
    actorManager->destroy(dstBeing);
}

References actorManager, ActorManager::destroy(), ActorManager::findBeing(), and Actions::msg().

processBeingRemoveSpecialEffect()

void EAthena::BeingRecv::processBeingRemoveSpecialEffect

(

Net::MessageIn &

msg

)

Definition at line 1518 of file beingrecv.cpp.

{
    UNIMPLEMENTEDPACKET;
    msg.readBeingId("being id");
    msg.readInt32("effect type");
}

References Actions::msg(), and UNIMPLEMENTEDPACKET.

processBeingResurrect()

void EAthena::BeingRecv::processBeingResurrect

(

Net::MessageIn &

msg

)

Definition at line 1656 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");
    msg.readInt16("unused");
    Being *const dstBeing = actorManager->findBeing(id);
    if (dstBeing == nullptr)
    {
        DEBUGLOGSTR("insible player?");
        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;
    }
 
    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 EAthena::BeingRecv::processBeingSelfEffect

(

Net::MessageIn &

msg

)

Definition at line 1887 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);
 
    BLOCK_END("BeingRecv::processBeingSelfEffect")
}

References actorManager, BLOCK_END, BLOCK_START, DEBUGLOGSTR, effectManager, ParticleEngine::enabled, ActorManager::findBeing(), Actions::msg(), and EffectManager::trigger().

processBeingSlide()

void EAthena::BeingRecv::processBeingSlide

(

Net::MessageIn &

msg

)

Definition at line 2029 of file beingrecv.cpp.

{
    if (actorManager == nullptr)
        return;
    Being *const dstBeing = actorManager->findBeing(
        msg.readBeingId("being id"));
    const int x = msg.readInt16("x");
    const int y = msg.readInt16("y");
    if (dstBeing == nullptr)
        return;
    if (localPlayer == dstBeing)
    {
        localPlayer->stopAttack(false);
        localPlayer->navigateClean();
        if (viewport != nullptr)
            viewport->returnCamera();
    }
 
    dstBeing->setAction(BeingAction::STAND, 0);
    dstBeing->setTileCoords(x, y);
}

References actorManager, ActorManager::findBeing(), localPlayer, Actions::msg(), LocalPlayer::navigateClean(), Viewport::returnCamera(), Being::setAction(), Being::setTileCoords(), BeingAction::STAND, LocalPlayer::stopAttack(), viewport, x, and y.

processBeingSoundEffect()

void EAthena::BeingRecv::processBeingSoundEffect

(

Net::MessageIn &

msg

)

Definition at line 1549 of file beingrecv.cpp.

{
    UNIMPLEMENTEDPACKET;
    // +++ need play this effect.
    msg.readString(24, "sound effect name");
    msg.readUInt8("type");
    msg.readInt32("unused");
    msg.readInt32("source being id");
}

References Actions::msg(), and UNIMPLEMENTEDPACKET.

processBeingSpawn()

void EAthena::BeingRecv::processBeingSpawn

(

Net::MessageIn &

msg

)

Definition at line 803 of file beingrecv.cpp.

{
    if (actorManager == nullptr)
        return;
 
    // need get type from id
    BeingTypeT type = BeingType::MONSTER;
    if (msg.getVersion() >= 20091103)
    {
        msg.readInt16("len");
        type = static_cast<BeingTypeT>(
            msg.readUInt8("object type"));
    }
 
    // Information about a being in range
    const BeingId id = msg.readBeingId("being id");
    if (msg.getVersion() >= 20131223)
    {
        msg.readBeingId("char id");
    }
    Ea::BeingRecv::mSpawnId = id;
    const BeingId spawnId = id;
    int16_t speed = msg.readInt16("speed");
    const uint32_t opt1 = msg.readInt16("opt1");
    // probably wrong effect usage
    const uint32_t opt2 = msg.readInt16("opt2");
    uint32_t option;
    if (msg.getVersion() >= 20080102)
        option = msg.readInt32("option");
    else
        option = msg.readInt16("option");
    const int16_t job = msg.readInt16("class");
 
    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)
    {
        if (actorManager->isBlocked(id) == true)
            return;
 
        dstBeing = createBeing2(msg, id, job, type);
        if (dstBeing == nullptr)
            return;
    }
    else
    {
        // undeleting marked for deletion being
        if (dstBeing->getType() == ActorType::Npc)
            actorManager->undelete(dstBeing);
    }
 
    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;
 
    dstBeing->setWalkSpeed(speed);
    dstBeing->setSubtype(fromInt(job, BeingTypeId), 0);
    if (dstBeing->getType() == ActorType::Monster && (localPlayer != nullptr))
        localPlayer->checkNewName(dstBeing);
 
    const int hairStyle = msg.readInt16("hair style");
    uint32_t weapon;
    if (msg.getVersion() >= 7)
    {
        weapon = msg.readItemId("weapon");
        msg.readItemId("shield");
    }
    else
    {
        weapon = CAST_U32(msg.readInt16("weapon"));
    }
    const uint16_t headBottom = msg.readInt16("head bottom");
    if (msg.getVersion() < 7)
        msg.readInt16("shield");
    const uint16_t headTop = msg.readInt16("head top");
    const uint16_t headMid = msg.readInt16("head mid");
    const ItemColor hairColor = fromInt(
        msg.readInt16("hair color"), ItemColor);
    const uint16_t shoes = msg.readInt16("shoes or clothes color?");
    const uint16_t gloves = msg.readInt16("head dir / gloves");
    // may be use robe as gloves?
    if (msg.getVersion() >= 20101124)
        msg.readInt16("robe");
    msg.readInt32("guild id");
    msg.readInt16("guild emblem");
    dstBeing->setManner(msg.readInt16("manner"));
    uint32_t opt3;
    if (msg.getVersion() >= 7)
        opt3 = msg.readInt32("opt3");
    else
        opt3 = msg.readInt16("opt3");
 
    dstBeing->setKarma(msg.readUInt8("karma"));
    const uint8_t gender = CAST_U8(msg.readUInt8("gender") & 3);
 
    setBasicFields(dstBeing,
        gender,
        hairStyle,
        hairColor,
        weapon,
        headBottom,
        headMid,
        headTop,
        shoes,
        gloves,
        true);
 
    uint8_t dir;
    uint16_t x;
    uint16_t y;
    msg.readCoordinates(x, y, dir, "position");
    msg.readInt8("xs");
    msg.readInt8("ys");
    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);
 
    const int level = CAST_S32(msg.readInt16("level"));
    if (level != 0)
        dstBeing->setLevel(level);
    if (msg.getVersion() >= 20080102)
        msg.readInt16("font");
    if (msg.getVersion() >= 20120221)
    {
        const int maxHP = msg.readInt32("max hp");
        const int hp = msg.readInt32("hp");
        dstBeing->setMaxHP(maxHP);
        dstBeing->setHP(hp);
        msg.readInt8("is boss");
    }
    if (msg.getVersion() >= 20150513)
    {
        msg.readInt16("body2");
    }
    if (msg.getVersion() >= 20131223)
    {
        msg.readString(24, "name");
    }
 
    dstBeing->setStatusEffectOpitons(option,
        opt1,
        opt2,
        opt3);
}

References actorManager, BeingId_zero, CAST_S32, CAST_U32, CAST_U8, LocalPlayer::checkNewName(), createBeing2(), ActorManager::destroy(), ActorManager::erase(), ActorManager::findBeing(), fromInt, KeyboardConfig::getKeyShortString(), SocialWindow::getPortalIndex(), Being::getType(), Being::isAlive(), ActorManager::isBlocked(), OutfitWindow::keyName(), localPlayer, ActorType::Monster, BeingType::MONSTER, Actions::msg(), Ea::BeingRecv::mSpawnId, ActorType::Npc, outfitWindow, ActorType::Player, Being::setAction(), EAthena::setBasicFields(), Being::setDirection(), Being::setHP(), Being::setKarma(), Being::setLevel(), Being::setManner(), Being::setMaxHP(), Being::setMoveTime(), Being::setName(), ActorSprite::setStatusEffectOpitons(), Being::setSubtype(), Being::setTileCoords(), Being::setWalkSpeed(), socialWindow, BeingAction::SPAWN, ActorManager::undelete(), x, and y.

processBeingSpecialEffect()

void EAthena::BeingRecv::processBeingSpecialEffect

(

Net::MessageIn &

msg

)

Definition at line 1492 of file beingrecv.cpp.

{
    if ((effectManager == nullptr) || (actorManager == nullptr))
        return;
 
    const BeingId id = msg.readBeingId("being id");
    Being *const being = actorManager->findBeing(id);
    if (being == nullptr)
    {
        msg.readInt32("effect type");
        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());
    }
}

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

processBeingSpecialEffectNum()

void EAthena::BeingRecv::processBeingSpecialEffectNum

(

Net::MessageIn &

msg

)

Definition at line 1539 of file beingrecv.cpp.

{
    UNIMPLEMENTEDPACKET;
    // +++ need somhow show this effects.
    // type is not same with self/misc effect.
    msg.readBeingId("account id");
    msg.readInt32("effect type");
    msg.readInt32("num");  // effect variable
}

References Actions::msg(), and UNIMPLEMENTEDPACKET.

processBeingStatUpdate1()

void EAthena::BeingRecv::processBeingStatUpdate1

(

Net::MessageIn &

msg

)

Definition at line 1867 of file beingrecv.cpp.

{
    const BeingId id = msg.readBeingId("account id");
    const int type = msg.readInt16("type");
    const int value = msg.readInt32("value");
 
    if (actorManager == nullptr)
        return;
    Being *const dstBeing = actorManager->findBeing(id);
    if (dstBeing == nullptr)
        return;
 
    if (type != Sp::MANNER)
    {
        UNIMPLEMENTEDPACKETFIELD(type);
        return;
    }
    dstBeing->setManner(value);
}

References actorManager, ActorManager::findBeing(), Sp::MANNER, Actions::msg(), Being::setManner(), and UNIMPLEMENTEDPACKETFIELD.

processBeingStatusChange()

void EAthena::BeingRecv::processBeingStatusChange

(

Net::MessageIn &

msg

)

Definition at line 1156 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);
    if (msg.getVersion() >= 20120618)
        msg.readInt32("total");
    if (msg.getVersion() >= 20090121)
    {
        msg.readInt32("left");
        msg.readInt32("val1");
        msg.readInt32("val2");
        msg.readInt32("val3");
    }
 
    const IsStart start = msg.getVersion() == 20090121 ?
        IsStart_false : IsStart_true;
 
    Being *const dstBeing = actorManager->findBeing(id);
    if (dstBeing != nullptr)
        dstBeing->setStatusEffect(status, flag, start);
    BLOCK_END("BeingRecv::processBeingStatusChange")
}

References actorManager, BLOCK_END, BLOCK_START, ActorManager::findBeing(), fromBool, IsStart_false, IsStart_true, Actions::msg(), ActorSprite::setStatusEffect(), and anonymous_namespace{stringutils.cpp}::start.

processBeingViewEquipment()

void EAthena::BeingRecv::processBeingViewEquipment

(

Net::MessageIn &

msg

)

Definition at line 2108 of file beingrecv.cpp.

{
    UNIMPLEMENTEDPACKET;
 
    const int count = (msg.readInt16("len") - 45) / (21 + itemIdLen * 5);
    msg.readString(24, "name");
    msg.readInt16("job");
    msg.readInt16("head");
    msg.readInt16("accessory");
    msg.readInt16("accessory2");
    msg.readInt16("accessory3");
    if (msg.getVersion() >= 20101124)
        msg.readInt16("robe");
    msg.readInt16("hair color");
    msg.readInt16("body color");
    msg.readUInt8("gender");
    for (int f = 0; f < count; f ++)
    {
        msg.readInt16("index");
        msg.readItemId("item id");
        msg.readUInt8("item type");
        msg.readInt32("location");
        msg.readInt32("wear state");
        msg.readInt8("refine");
        for (int d = 0; d < maxCards; d ++)
            msg.readItemId("card");
        msg.readInt32("hire expire date (?)");
        msg.readInt16("equip type");
        msg.readInt16("item sprite number");
        msg.readUInt8("flags");
    }
}

References itemIdLen, maxCards, Actions::msg(), and UNIMPLEMENTEDPACKET.

processBeingViewEquipment2()

void EAthena::BeingRecv::processBeingViewEquipment2

(

Net::MessageIn &

msg

)

Definition at line 2141 of file beingrecv.cpp.

{
    UNIMPLEMENTEDPACKET;
 
    const int count = (msg.readInt16("len") - 47) / (21 + itemIdLen * 5);
    msg.readString(24, "name");
    msg.readInt16("job");
    msg.readInt16("head");
    msg.readInt16("accessory");
    msg.readInt16("accessory2");
    msg.readInt16("accessory3");
    msg.readInt16("robe");
    msg.readInt16("hair color");
    msg.readInt16("body color");
    msg.readInt16("body2");
    msg.readUInt8("gender");
    for (int f = 0; f < count; f ++)
    {
        msg.readInt16("index");
        msg.readItemId("item id");
        msg.readUInt8("item type");
        msg.readInt32("location");
        msg.readInt32("wear state");
        msg.readInt8("refine");
        for (int d = 0; d < maxCards; d ++)
            msg.readItemId("card");
        msg.readInt32("hire expire date (?)");
        msg.readInt16("equip type");
        msg.readInt16("item sprite number");
        msg.readUInt8("flags");
    }
}

References itemIdLen, maxCards, Actions::msg(), and UNIMPLEMENTEDPACKET.

processBeingVisible()

void EAthena::BeingRecv::processBeingVisible

(

Net::MessageIn &

msg

)

Definition at line 419 of file beingrecv.cpp.

{
    if (actorManager == nullptr)
        return;
 
    // need set type based on id
    BeingTypeT type = BeingType::MONSTER;
    if (msg.getVersion() >= 20091103)
    {
        msg.readInt16("len");
        type = static_cast<BeingTypeT>(
            msg.readUInt8("object type"));
    }
 
    // Information about a being in range
    const BeingId id = msg.readBeingId("being id");
    if (msg.getVersion() >= 20131223)
        msg.readBeingId("char id");
    BeingId spawnId;
    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");
    // probably wrong effect usage
    const uint32_t opt2 = msg.readInt16("opt2");
    uint32_t option;
    if (msg.getVersion() >= 20080102)
        option = msg.readInt32("option");
    else
        option = msg.readInt16("option");
    const int16_t job = msg.readInt16("class");
 
    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)
    {
        if (actorManager->isBlocked(id) == true)
            return;
 
        dstBeing = createBeing2(msg, id, job, type);
        if (dstBeing == nullptr)
            return;
    }
    else
    {
        // undeleting marked for deletion being
        if (dstBeing->getType() == ActorType::Npc)
            actorManager->undelete(dstBeing);
    }
 
    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;
 
    dstBeing->setWalkSpeed(speed);
    dstBeing->setSubtype(fromInt(job, BeingTypeId), 0);
    if (dstBeing->getType() == ActorType::Monster && (localPlayer != nullptr))
        localPlayer->checkNewName(dstBeing);
 
    const int hairStyle = msg.readInt16("hair style");
    uint32_t weapon;
    if (msg.getVersion() >= 7)
    {
        weapon = msg.readItemId("weapon");
        msg.readItemId("shield");
    }
    else
    {
        weapon = CAST_U32(msg.readInt16("weapon"));
    }
    const uint16_t headBottom = msg.readInt16("head bottom");
    if (msg.getVersion() < 7)
        msg.readInt16("shield");
    const uint16_t headTop = msg.readInt16("head top");
    const uint16_t headMid = msg.readInt16("head mid");
    const ItemColor hairColor = fromInt(msg.readInt16("hair color"),
        ItemColor);
    const uint16_t shoes = msg.readInt16("shoes or clothes color?");
 
    const uint16_t gloves = msg.readInt16("head dir / gloves");
    // may be use robe as gloves?
    if (msg.getVersion() >= 20101124)
        msg.readInt16("robe");
    msg.readInt32("guild id");
    msg.readInt16("guild emblem");
    dstBeing->setManner(msg.readInt16("manner"));
    uint32_t opt3;
    if (msg.getVersion() >= 7)
        opt3 = msg.readInt32("opt3");
    else
        opt3 = msg.readInt16("opt3");
    dstBeing->setKarma(msg.readUInt8("karma"));
    const uint8_t gender = CAST_U8(msg.readUInt8("gender") & 3);
 
    setBasicFields(dstBeing,
        gender,
        hairStyle,
        hairColor,
        weapon,
        headBottom,
        headMid,
        headTop,
        shoes,
        gloves,
        true);
 
    uint8_t dir;
    uint16_t x;
    uint16_t y;
    msg.readCoordinates(x, y, dir, "position");
    msg.readInt8("xs");
    msg.readInt8("ys");
    applyPlayerAction(msg, dstBeing, msg.readUInt8("action type"));
    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);
 
    const int level = CAST_S32(msg.readInt16("level"));
    if (level != 0)
        dstBeing->setLevel(level);
    if (msg.getVersion() >= 20080102)
        msg.readInt16("font");
 
    if (msg.getVersion() >= 20120221)
    {
        const int maxHP = msg.readInt32("max hp");
        const int hp = msg.readInt32("hp");
        dstBeing->setMaxHP(maxHP);
        dstBeing->setHP(hp);
        msg.readInt8("is boss");
    }
 
    if (msg.getVersion() >= 20150513)
    {
        msg.readInt16("body2");
    }
    if (msg.getVersion() >= 20131223)
    {
        msg.readString(24, "name");
    }
 
    dstBeing->setStatusEffectOpitons(option,
        opt1,
        opt2,
        opt3);
}

References actorManager, applyPlayerAction(), BeingId_zero, CAST_S32, CAST_U32, CAST_U8, LocalPlayer::checkNewName(), Being::clearPath(), createBeing2(), ActorManager::destroy(), ActorManager::erase(), ActorManager::findBeing(), fromInt, KeyboardConfig::getKeyShortString(), SocialWindow::getPortalIndex(), Being::getType(), Being::isAlive(), ActorManager::isBlocked(), OutfitWindow::keyName(), localPlayer, ActorType::Monster, BeingType::MONSTER, Actions::msg(), Ea::BeingRecv::mSpawnId, ActorType::Npc, outfitWindow, ActorType::Player, Being::setAction(), Being::setActionTime(), EAthena::setBasicFields(), Being::setDirection(), Being::setHP(), Being::setKarma(), Being::setLevel(), Being::setManner(), Being::setMaxHP(), Being::setMoveTime(), Being::setName(), ActorSprite::setStatusEffectOpitons(), Being::setSubtype(), Being::setTileCoords(), Being::setWalkSpeed(), socialWindow, BeingAction::SPAWN, BeingAction::STAND, tick_time, ActorManager::undelete(), x, and y.

processBlacksmithRanksList()

void EAthena::BeingRecv::processBlacksmithRanksList

(

Net::MessageIn &

msg

)

Definition at line 1423 of file beingrecv.cpp.

{
    UNIMPLEMENTEDPACKET;
    // +++ here need window with rank tables.
    for (int f = 0; f < 10; f ++)
        msg.readString(24, "name");
    for (int f = 0; f < 10; f ++)
        msg.readInt32("points");
}

References Actions::msg(), and UNIMPLEMENTEDPACKET.

processBladeStop()

void EAthena::BeingRecv::processBladeStop

(

Net::MessageIn &

msg

)

Definition at line 2005 of file beingrecv.cpp.

{
    UNIMPLEMENTEDPACKET;
 
    msg.readInt32("src being id");
    msg.readInt32("dst being id");
    msg.readInt32("flag");
}

References Actions::msg(), and UNIMPLEMENTEDPACKET.

processBossMapInfo()

void EAthena::BeingRecv::processBossMapInfo

(

Net::MessageIn &

msg

)

Definition at line 2068 of file beingrecv.cpp.

{
    UNIMPLEMENTEDPACKET;
 
    msg.readUInt8("info type");
    msg.readInt32("x");
    msg.readInt32("y");
    msg.readInt16("min hours");
    msg.readInt16("min minutes");
    msg.readInt16("max hours");
    msg.readInt16("max minutes");
    msg.readString(24, "monster name");  // really can be used 51 byte?
}

References Actions::msg(), and UNIMPLEMENTEDPACKET.

processClassChange()

void EAthena::BeingRecv::processClassChange

(

Net::MessageIn &

msg

)

Definition at line 1985 of file beingrecv.cpp.

{
    UNIMPLEMENTEDPACKET;
 
    msg.readBeingId("being id");
    msg.readUInt8("type");
    msg.readInt32("class");
}

References Actions::msg(), and UNIMPLEMENTEDPACKET.

processComboDelay()

void EAthena::BeingRecv::processComboDelay

(

Net::MessageIn &

msg

)

Definition at line 2014 of file beingrecv.cpp.

{
    UNIMPLEMENTEDPACKET;
 
    msg.readBeingId("being id");
    msg.readInt32("wait");
}

References Actions::msg(), and UNIMPLEMENTEDPACKET.

processGladiatorFeelRequest()

void EAthena::BeingRecv::processGladiatorFeelRequest

(

Net::MessageIn &

msg

)

Definition at line 2061 of file beingrecv.cpp.

{
    UNIMPLEMENTEDPACKET;
 
    msg.readUInt8("which");
}

References Actions::msg(), and UNIMPLEMENTEDPACKET.

processGraffiti()

void EAthena::BeingRecv::processGraffiti

(

Net::MessageIn &

msg

)

Definition at line 2328 of file beingrecv.cpp.

{
    const BeingId id = msg.readBeingId("graffiti id");
    const BeingId creatorId = msg.readBeingId("creator id");
    const int x = msg.readInt16("x");
    const int y = msg.readInt16("y");
    const int job = msg.readUInt8("job");
    msg.readUInt8("visible");
    msg.readUInt8("is content");
    const std::string text = msg.readString(80, "text");
 
    Being *const dstBeing = createBeing2(msg, id, job, BeingType::SKILL);
    if (dstBeing == nullptr)
        return;
 
    dstBeing->setAction(BeingAction::STAND, 0);
    dstBeing->setTileCoords(x, y);
    dstBeing->setShowName(true);
    dstBeing->setName(text);
    dstBeing->setCreatorId(creatorId);
}

References createBeing2(), Actions::msg(), Being::setAction(), Being::setCreatorId(), Being::setName(), Being::setShowName(), Being::setTileCoords(), BeingType::SKILL, BeingAction::STAND, x, and y.

processMapType()

void EAthena::BeingRecv::processMapType

(

Net::MessageIn &

msg

)

Definition at line 995 of file beingrecv.cpp.

{
    const int16_t type = msg.readInt16("type");
    if (type == 19)
        NotifyManager::notify(NotifyTypes::MAP_TYPE_BATTLEFIELD);
    else
        UNIMPLEMENTEDPACKETFIELD(type);
}

References NotifyTypes::MAP_TYPE_BATTLEFIELD, Actions::msg(), NotifyManager::notify(), and UNIMPLEMENTEDPACKETFIELD.

processMapTypeProperty()

void EAthena::BeingRecv::processMapTypeProperty

(

Net::MessageIn &

msg

)

Definition at line 976 of file beingrecv.cpp.

{
    const int16_t type = msg.readInt16("type");
    const int flags = msg.readInt32("flags");
    if (type == 0x28)
    {
        // +++ need get other flags from here
        MapTypeProperty2 props;
        props.data = CAST_U32(flags);
        const Game *const game = Game::instance();
        if (game == nullptr)
            return;
        Map *const map = game->getCurrentMap();
        if (map == nullptr)
            return;
        map->setPvpMode(props.bits.party | (props.bits.guild * 2));
    }
}

References EAthena::MapTypeProperty2::bits, CAST_U32, EAthena::MapTypeProperty2::data, Game::getCurrentMap(), EAthena::MapTypeProperty2Bits::guild, Game::instance(), Actions::msg(), EAthena::MapTypeProperty2Bits::party, and Map::setPvpMode().

processMobInfo()

void EAthena::BeingRecv::processMobInfo

(

Net::MessageIn &

msg

)

Definition at line 1913 of file beingrecv.cpp.

{
    if (actorManager == nullptr)
        return;
    const int len = msg.readInt16("len");
    if (len < 12)
        return;
    Being *const dstBeing = actorManager->findBeing(
        msg.readBeingId("monster id"));
    const int attackRange = msg.readInt32("range");
    if (dstBeing != nullptr)
        dstBeing->setAttackRange(attackRange);
}

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

processMonsterHp()

void EAthena::BeingRecv::processMonsterHp

(

Net::MessageIn &

msg

)

Definition at line 1364 of file beingrecv.cpp.

{
    if (actorManager == nullptr)
        return;
    Being *const dstBeing = actorManager->findBeing(
        msg.readBeingId("monster id"));
    const int hp = msg.readInt32("hp");
    const int maxHP = msg.readInt32("max hp");
    if (dstBeing != nullptr)
    {
        dstBeing->setHP(hp);
        dstBeing->setMaxHP(maxHP);
    }
}

References actorManager, ActorManager::findBeing(), Actions::msg(), Being::setHP(), and Being::setMaxHP().

processMonsterInfo()

void EAthena::BeingRecv::processMonsterInfo

(

Net::MessageIn &

msg

)

Definition at line 1971 of file beingrecv.cpp.

{
    UNIMPLEMENTEDPACKET;
 
    msg.readInt16("class");
    msg.readInt16("level");
    msg.readInt16("size");
    msg.readInt32("hp");
    msg.readInt16("def");
    msg.readInt16("race");
    msg.readInt16("mdef");
    msg.readInt16("ele");
}

References Actions::msg(), and UNIMPLEMENTEDPACKET.

processNameResponse2()

void EAthena::BeingRecv::processNameResponse2

(

Net::MessageIn &

msg

)

Definition at line 2189 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processNameResponse2")
    if ((actorManager == nullptr) || (localPlayer == nullptr))
    {
        BLOCK_END("BeingRecv::processNameResponse2")
        return;
    }
 
    const int len = msg.readInt16("len");
    const BeingId beingId = msg.readBeingId("account id");
    const std::string str = msg.readString(len - 8, "name");
    actorManager->updateNameId(str, beingId);
    Being *const dstBeing = actorManager->findBeing(beingId);
    if (dstBeing != nullptr)
    {
        if (beingId == localPlayer->getId())
        {
            localPlayer->pingResponse();
        }
        else
        {
            dstBeing->setName(str);
            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::processNameResponse2")
}

References actorManager, Being::addToCache(), BLOCK_END, BLOCK_START, LocalPlayer::checkNewName(), ActorManager::findBeing(), ActorSprite::getId(), Being::getName(), Being::getParty(), Being::getType(), localPlayer, Actions::msg(), party, LocalPlayer::pingResponse(), ActorType::Player, Avatar::setName(), Being::setName(), Being::updateColors(), Being::updateGuild(), and ActorManager::updateNameId().

processNameResponseTitle()

void EAthena::BeingRecv::processNameResponseTitle

(

Net::MessageIn &

msg

)

Definition at line 1692 of file beingrecv.cpp.

{
    if (actorManager == nullptr)
        return;
 
    const BeingId beingId = msg.readBeingId("being id");
    msg.readInt32("group id");  // +++ can be used for icon or other
    const std::string name = msg.readString(24, "name");
    msg.readString(24, "title");  // +++ can be used for second name part
    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);
            }
            return;
        }
    }
}

References actorManager, Map::addPortalTile(), Being::addToCache(), 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.

processNavigateTo()

void EAthena::BeingRecv::processNavigateTo

(

Net::MessageIn &

msg

)

Definition at line 2382 of file beingrecv.cpp.

{
    UNIMPLEMENTEDPACKET;
    // 0 position
    // 1 no position
    // 3 monster
    msg.readUInt8("navigate type");
    msg.readUInt8("transportation flag");
    msg.readUInt8("hide window");
    msg.readString(16, "map name");
    msg.readInt16("x");
    msg.readInt16("y");
    msg.readInt16("mob id");
}

References Actions::msg(), and UNIMPLEMENTEDPACKET.

processPkRanksList()

void EAthena::BeingRecv::processPkRanksList

(

Net::MessageIn &

msg

)

Definition at line 1453 of file beingrecv.cpp.

{
    UNIMPLEMENTEDPACKET;
    // +++ here need window with rank tables.
    for (int f = 0; f < 10; f ++)
        msg.readString(24, "name");
    for (int f = 0; f < 10; f ++)
        msg.readInt32("points");
}

References Actions::msg(), and UNIMPLEMENTEDPACKET.

processPlayerGuilPartyInfo()

void EAthena::BeingRecv::processPlayerGuilPartyInfo

(

Net::MessageIn &

msg

)

Definition at line 1750 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processPlayerGuilPartyInfo")
    if (actorManager == nullptr)
    {
        BLOCK_END("BeingRecv::processPlayerGuilPartyInfo")
        return;
    }
 
    const BeingId beingId = msg.readBeingId("being id");
    const std::string name = msg.readString(24, "char name");
    actorManager->updateNameId(name, beingId);
    Being *const dstBeing = actorManager->findBeing(beingId);
    if (dstBeing != nullptr)
    {
        if (beingId == localPlayer->getId())
        {
            localPlayer->pingResponse();
        }
        dstBeing->setName(name);
        dstBeing->setPartyName(msg.readString(24, "party name"));
        dstBeing->setGuildName(msg.readString(24, "guild name"));
        dstBeing->setGuildPos(msg.readString(24, "guild pos"));
        dstBeing->addToCache();
    }
    else
    {
        msg.readString(24, "party name");
        msg.readString(24, "guild name");
        msg.readString(24, "guild pos");
    }
    BLOCK_END("BeingRecv::processPlayerGuilPartyInfo")
}

References actorManager, Being::addToCache(), BLOCK_END, BLOCK_START, ActorManager::findBeing(), ActorSprite::getId(), localPlayer, Actions::msg(), LocalPlayer::pingResponse(), Being::setGuildName(), Being::setGuildPos(), Being::setName(), Being::setPartyName(), and ActorManager::updateNameId().

processPlayerGuilPartyInfo2()

void EAthena::BeingRecv::processPlayerGuilPartyInfo2

(

Net::MessageIn &

msg

)

Definition at line 1784 of file beingrecv.cpp.

{
    BLOCK_START("BeingRecv::processPlayerGuilPartyInfo2")
    if (actorManager == nullptr)
    {
        BLOCK_END("BeingRecv::processPlayerGuilPartyInfo2")
        return;
    }
 
    const BeingId beingId = msg.readBeingId("being id");
    const std::string name = msg.readString(24, "char name");
    actorManager->updateNameId(name, beingId);
    Being *const dstBeing = actorManager->findBeing(beingId);
    if (dstBeing != nullptr)
    {
        if (beingId == localPlayer->getId())
        {
            localPlayer->pingResponse();
        }
        dstBeing->setName(name);
        dstBeing->setPartyName(msg.readString(24, "party name"));
        dstBeing->setGuildName(msg.readString(24, "guild name"));
        dstBeing->setGuildPos(msg.readString(24, "guild pos"));
        dstBeing->addToCache();
    }
    else
    {
        msg.readString(24, "party name");
        msg.readString(24, "guild name");
        msg.readString(24, "guild pos");
    }
    // +++ need use it for show player title
    msg.readInt32("title");
    BLOCK_END("BeingRecv::processPlayerGuilPartyInfo2")
}

References actorManager, Being::addToCache(), BLOCK_END, BLOCK_START, ActorManager::findBeing(), ActorSprite::getId(), localPlayer, Actions::msg(), LocalPlayer::pingResponse(), Being::setGuildName(), Being::setGuildPos(), Being::setName(), Being::setPartyName(), and ActorManager::updateNameId().

processPlayerStatusChange()

void EAthena::BeingRecv::processPlayerStatusChange

(

Net::MessageIn &

msg

)

Definition at line 1599 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)
    {
        msg.readInt16("opt1");
        msg.readInt16("opt2");
        if (msg.getVersion() >= 7)
            msg.readInt32("option");
        else
            msg.readInt16("option");
        msg.readUInt8("karma");
        return;
    }
 
    const uint32_t opt1 = msg.readInt16("opt1");
    const uint32_t opt2 = msg.readInt16("opt2");
    uint32_t option;
    if (msg.getVersion() >= 7)
        option = msg.readInt32("option");
    else
        option = msg.readInt16("option");
    dstBeing->setKarma(msg.readUInt8("karma"));
 
    dstBeing->setStatusEffectOpitons(option,
        opt1,
        opt2);
    BLOCK_END("BeingRecv::processPlayerStop")
}

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

processPlayerStatusChange2()

void EAthena::BeingRecv::processPlayerStatusChange2

(

Net::MessageIn &

msg

)

Definition at line 1638 of file beingrecv.cpp.

{
    if (actorManager == nullptr)
        return;
 
    // look like this function unused on server
 
    const BeingId id = msg.readBeingId("account id");
    Being *const dstBeing = actorManager->findBeing(id);
    if (dstBeing == nullptr)
        return;
 
    const uint32_t option = msg.readInt32("option");
    dstBeing->setLevel(msg.readInt32("level"));
    msg.readInt32("showEFST");
    dstBeing->setStatusEffectOpiton0(option);
}

References actorManager, ActorManager::findBeing(), Actions::msg(), Being::setLevel(), and ActorSprite::setStatusEffectOpiton0().

processPvpSet()

void EAthena::BeingRecv::processPvpSet

(

Net::MessageIn &

msg

)

Definition at line 2174 of file beingrecv.cpp.

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

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

processRanksList1()

void EAthena::BeingRecv::processRanksList1

(

Net::MessageIn &

msg

)

Definition at line 1397 of file beingrecv.cpp.

{
    UNIMPLEMENTEDPACKET;
    // +++ here need window with rank tables.
    const int count = (msg.readInt16("len") - 4) / 28;
    msg.readInt16("rank type");
    for (int f = 0; f < count; f ++)
    {
        msg.readString(24, "name");
        msg.readInt32("points");
    }
    msg.readInt32("my points");
}

References Actions::msg(), and UNIMPLEMENTEDPACKET.

processRanksList2()

void EAthena::BeingRecv::processRanksList2

(

Net::MessageIn &

msg

)

Definition at line 1411 of file beingrecv.cpp.

{
    UNIMPLEMENTEDPACKET;
    // +++ here need window with rank tables.
    msg.readInt16("rank type");
    for (int f = 0; f < 10; f ++)
        msg.readBeingId("char id");
    for (int f = 0; f < 10; f ++)
        msg.readInt32("points");
    msg.readInt32("my points");
}

References Actions::msg(), and UNIMPLEMENTEDPACKET.

processSkillAutoCast()

void EAthena::BeingRecv::processSkillAutoCast

(

Net::MessageIn &

msg

)

Definition at line 1379 of file beingrecv.cpp.

{
    const int id = msg.readInt16("skill id");
    msg.readInt16("inf");
    msg.readInt16("unused");
    const int level = msg.readInt16("skill level");
    msg.readInt16("sp");
    msg.readInt16("range");
    msg.readString(24, "skill name");
    msg.readInt8("unused");
 
    if (localPlayer != nullptr)
    {
        localPlayer->handleSkill(localPlayer, 0, id, level);
        localPlayer->takeDamage(localPlayer, 0, AttackType::SKILL, id, level);
    }
}

References Being::handleSkill(), localPlayer, Actions::msg(), AttackType::SKILL, and Being::takeDamage().

processSkillCancel()

void EAthena::BeingRecv::processSkillCancel

(

Net::MessageIn &

msg

)

Definition at line 2303 of file beingrecv.cpp.

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

References Actions::msg().

processSkillCasting()

void EAthena::BeingRecv::processSkillCasting

(

Net::MessageIn &

msg

)

Definition at line 1004 of file beingrecv.cpp.

{
    const BeingId srcId = msg.readBeingId("src id");
    const BeingId dstId = msg.readBeingId("dst id");
    const int dstX = msg.readInt16("dst x");
    const int dstY = msg.readInt16("dst y");
    const int skillId = msg.readInt16("skill id");
    msg.readInt32("element");  // +++ use different effects
    const int castTime = msg.readInt32("cast time");
 
    processSkillCastingContinue(msg,
        srcId, dstId,
        dstX, dstY,
        skillId,
        1,
        0,
        SkillType2::Unknown,
        castTime);
}

References Actions::msg(), processSkillCastingContinue(), and SkillType2::Unknown.

processSkillCasting2()

void EAthena::BeingRecv::processSkillCasting2

(

Net::MessageIn &

msg

)

Definition at line 1024 of file beingrecv.cpp.

{
    const BeingId srcId = msg.readBeingId("src id");
    const BeingId dstId = msg.readBeingId("dst id");
    const int dstX = msg.readInt16("dst x");
    const int dstY = msg.readInt16("dst y");
    const int skillId = msg.readInt16("skill id");
    msg.readInt32("element");  // +++ use different effects
    const int castTime = msg.readInt32("cast time");
    msg.readInt8("dispossable");
 
    processSkillCastingContinue(msg,
        srcId, dstId,
        dstX, dstY,
        skillId,
        1,
        0,
        SkillType2::Unknown,
        castTime);
}

References Actions::msg(), processSkillCastingContinue(), and SkillType2::Unknown.

processSkillCasting3()

void EAthena::BeingRecv::processSkillCasting3

(

Net::MessageIn &

msg

)

Definition at line 1045 of file beingrecv.cpp.

{
    const BeingId srcId = msg.readBeingId("src id");
    const BeingId dstId = msg.readBeingId("dst id");
    const int dstX = msg.readInt16("dst x");
    const int dstY = msg.readInt16("dst y");
    const int skillId = msg.readInt16("skill id");
    msg.readInt32("element");  // +++ use different effects
    const int castTime = msg.readInt32("cast time");
    msg.readInt8("dispossable");
    msg.readInt32("unknown");
 
    processSkillCastingContinue(msg,
        srcId, dstId,
        dstX, dstY,
        skillId,
        1,
        0,
        SkillType2::Unknown,
        castTime);
}

References Actions::msg(), processSkillCastingContinue(), and SkillType2::Unknown.

processSkillCastingContinue()

void EAthena::BeingRecv::processSkillCastingContinue	(	Net::MessageIn &	msg,
		const BeingId	srcId,
		const BeingId	dstId,
		const int	dstX,
		const int	dstY,
		const int	skillId,
		const int	skillLevel,
		const int	range,
		const SkillType2::SkillType2	inf2,
		const int	castTime
	)

Definition at line 1093 of file beingrecv.cpp.

{
    if (effectManager == nullptr ||
        actorManager == nullptr)
        return;
 
    if (srcId == BeingId_zero)
    {
        UNIMPLEMENTEDPACKETFIELD(0);
        return;
    }
    Being *const srcBeing = actorManager->findBeing(srcId);
    if (dstId != BeingId_zero)
    {   // being to being
        Being *const dstBeing = actorManager->findBeing(dstId);
        if (srcBeing != nullptr)
        {
            srcBeing->handleSkillCasting(dstBeing, skillId, skillLevel);
            if (dstBeing != nullptr)
            {
                srcBeing->addCast(dstBeing->getTileX(),
                    dstBeing->getTileY(),
                    skillId,
                    skillLevel,
                    range,
                    castTime / MILLISECONDS_IN_A_TICK);
            }
        }
    }
    else if (dstX != 0 || dstY != 0)
    {   // being to position
        if (srcBeing != nullptr)
            srcBeing->setAction(BeingAction::CAST, skillId);
        skillDialog->playCastingDstTileEffect(skillId,
            skillLevel,
            dstX, dstY,
            castTime);
        if (srcBeing != nullptr)
        {
            srcBeing->addCast(dstX, dstY,
                skillId,
                skillLevel,
                range,
                castTime / MILLISECONDS_IN_A_TICK);
        }
    }
    if ((localPlayer != nullptr) &&
        srcBeing == localPlayer &&
        (inf2 & SkillType2::FreeCastAny) == 0)
    {
        localPlayer->freezeMoving(castTime / MILLISECONDS_IN_A_TICK);
    }
}

References actorManager, Being::addCast(), BeingId_zero, BeingAction::CAST, effectManager, ActorManager::findBeing(), SkillType2::FreeCastAny, LocalPlayer::freezeMoving(), Being::getTileX(), Being::getTileY(), Being::handleSkillCasting(), localPlayer, MILLISECONDS_IN_A_TICK, SkillDialog::playCastingDstTileEffect(), Being::setAction(), skillDialog, and UNIMPLEMENTEDPACKETFIELD.

Referenced by processSkillCasting(), processSkillCasting2(), processSkillCasting3(), and processSkillCastingEvol().

processSkillCastingEvol()

void EAthena::BeingRecv::processSkillCastingEvol

(

Net::MessageIn &

msg

)

Definition at line 1067 of file beingrecv.cpp.

{
    msg.readInt16("len");  // for now unused
    const BeingId srcId = msg.readBeingId("src id");
    const BeingId dstId = msg.readBeingId("dst id");
    const int dstX = msg.readInt16("dst x");
    const int dstY = msg.readInt16("dst y");
    const int skillId = msg.readInt16("skill id");
    const int skillLevel = msg.readInt16("skill level");
    msg.readInt32("element");  // +++ use different effects
    const int castTime = msg.readInt32("cast time");
    const int range = msg.readInt32("skill range");
    const SkillType2::SkillType2 inf2 =
        static_cast<SkillType2::SkillType2>(msg.readInt32("inf2"));
    // +++ add new unknown field
 
    processSkillCastingContinue(msg,
        srcId, dstId,
        dstX, dstY,
        skillId,
        skillLevel,
        range,
        inf2,
        castTime);
}

References Actions::msg(), and processSkillCastingContinue().

processSkillDamage()

void EAthena::BeingRecv::processSkillDamage

(

Net::MessageIn &

msg

)

Definition at line 2350 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");
    int param1;
    if (msg.getVersion() >= 3)
        param1 = msg.readInt32("damage");
    else
        param1 = msg.readInt16("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().

processSkillEntry()

void EAthena::BeingRecv::processSkillEntry

(

Net::MessageIn &

msg

)

Definition at line 1570 of file beingrecv.cpp.

{
    if (msg.getVersion() >= 20110718)
        msg.readInt16("len");
    const BeingId id = msg.readBeingId("skill unit id");
    const BeingId creatorId = msg.readBeingId("creator accound id");
    const int x = msg.readInt16("x");
    const int y = msg.readInt16("y");
    int job = 0;
    if (msg.getVersion() >= 20121212)
        job = msg.readInt32("job");
    if (msg.getVersion() >= 20110718)
        msg.readUInt8("radius");
    msg.readUInt8("visible");
    int level = 0;
    if (msg.getVersion() >= 20130731)
        level = msg.readUInt8("level");
    Being *const dstBeing = createBeing2(msg,
        id,
        job,
        BeingType::SKILL);
    if (dstBeing == nullptr)
        return;
    dstBeing->setAction(BeingAction::STAND, 0);
    dstBeing->setTileCoords(x, y);
    dstBeing->setLevel(level);
    dstBeing->setCreatorId(creatorId);
}

References createBeing2(), Actions::msg(), Being::setAction(), Being::setCreatorId(), Being::setLevel(), Being::setTileCoords(), BeingType::SKILL, BeingAction::STAND, x, and y.

processSkillGroundNoDamage()

void EAthena::BeingRecv::processSkillGroundNoDamage

(

Net::MessageIn &

msg

)

Definition at line 1559 of file beingrecv.cpp.

{
    UNIMPLEMENTEDPACKET;
    msg.readInt16("skill id");
    msg.readInt32("src id");
    msg.readInt16("val");
    msg.readInt16("x");
    msg.readInt16("y");
    msg.readInt32("tick");
}

References Actions::msg(), and UNIMPLEMENTEDPACKET.

processSolveCharName()

void EAthena::BeingRecv::processSolveCharName

(

Net::MessageIn &

msg

)

Definition at line 2308 of file beingrecv.cpp.

{
    if ((packets_re == true && msg.getVersion() >= 20180221) ||
        (packets_main == true && msg.getVersion() >= 20180307) ||
        (packets_zero == true && msg.getVersion() >= 20180328))
    {
        const int flag = msg.readInt16("flag");
        // name request errors
        if (flag != 3)
            return;
    }
    const int id = msg.readInt32("char id");
    if (actorManager == nullptr)
    {
        msg.readString(24, "name");
        return;
    }
    actorManager->addChar(id, msg.readString(24, "name"));
}

References actorManager, ActorManager::addChar(), Actions::msg(), packets_main, packets_re, and packets_zero.

processSpiritBalls()

void EAthena::BeingRecv::processSpiritBalls

(

Net::MessageIn &

msg

)

Definition at line 1994 of file beingrecv.cpp.

{
    if (actorManager == nullptr)
        return;
    Being *const dstBeing = actorManager->findBeing(
        msg.readBeingId("being id"));
    const int balls = msg.readInt16("spirits amount");
    if (dstBeing != nullptr)
        dstBeing->setSpiritBalls(balls);
}

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

processStarsKill()

void EAthena::BeingRecv::processStarsKill

(

Net::MessageIn &

msg

)

Definition at line 2051 of file beingrecv.cpp.

{
    UNIMPLEMENTEDPACKET;
 
    msg.readString(24, "map name");
    msg.readInt32("monster id");
    msg.readUInt8("start");
    msg.readUInt8("result");
}

References Actions::msg(), and UNIMPLEMENTEDPACKET.

processTaekwonRanksList()

void EAthena::BeingRecv::processTaekwonRanksList

(

Net::MessageIn &

msg

)

Definition at line 1443 of file beingrecv.cpp.

{
    UNIMPLEMENTEDPACKET;
    // +++ here need window with rank tables.
    for (int f = 0; f < 10; f ++)
        msg.readString(24, "name");
    for (int f = 0; f < 10; f ++)
        msg.readInt32("points");
}

References Actions::msg(), and UNIMPLEMENTEDPACKET.

processWddingEffect()

void EAthena::BeingRecv::processWddingEffect

(

Net::MessageIn &

msg

)

Definition at line 2022 of file beingrecv.cpp.

{
    UNIMPLEMENTEDPACKET;
 
    msg.readBeingId("being id");
}

References Actions::msg(), and UNIMPLEMENTEDPACKET.