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().