Ea::BeingRecv Namespace Reference

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

Variables
BeingId	mSpawnId = BeingId_zero
bool	mSync

Function Documentation

createBeing()

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

Definition at line 507 of file beingrecv.cpp.

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

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

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

processBeingAction()

void Ea::BeingRecv::processBeingAction

(

Net::MessageIn &

msg

)

Definition at line 149 of file beingrecv.cpp.

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

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

processBeingEmotion()

void Ea::BeingRecv::processBeingEmotion

(

Net::MessageIn &

msg

)

Definition at line 244 of file beingrecv.cpp.

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

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

processBeingMove3()

void Ea::BeingRecv::processBeingMove3

(

Net::MessageIn &

msg

)

Definition at line 418 of file beingrecv.cpp.

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

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

processBeingRemove()

void Ea::BeingRecv::processBeingRemove

(

Net::MessageIn &

msg

)

Definition at line 61 of file beingrecv.cpp.

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

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

processNameResponse()

void Ea::BeingRecv::processNameResponse

(

Net::MessageIn &

msg

)

Definition at line 275 of file beingrecv.cpp.

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

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

processPlayerMoveToAttack()

void Ea::BeingRecv::processPlayerMoveToAttack

(

Net::MessageIn &

msg

)

Definition at line 367 of file beingrecv.cpp.

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

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

processPlayerStop()

void Ea::BeingRecv::processPlayerStop

(

Net::MessageIn &

msg

)

Definition at line 337 of file beingrecv.cpp.

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

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

processPvpMapMode()

void Ea::BeingRecv::processPvpMapMode

(

Net::MessageIn &

msg

)

Definition at line 402 of file beingrecv.cpp.

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

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

processSkillNoDamage()

void Ea::BeingRecv::processSkillNoDamage

(

Net::MessageIn &

msg

)

Definition at line 382 of file beingrecv.cpp.

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

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

Variable Documentation

mSpawnId

BeingId Ea::BeingRecv::mSpawnId = BeingId_zero

Definition at line 58 of file beingrecv.cpp.

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

mSync

bool Ea::BeingRecv::mSync

extern

Referenced by Graphics::setSync().