void CrazyMoves::crazyMoveAe() const
{
settings.crazyMoveState ++;
const signed char emo = mMoveProgram[settings.crazyMoveState];
unsigned char emoteId = 0;
if (emo == '?')
{
srand(tick_time);
emoteId = CAST_U8(
1 + (rand() % EmoteDB::size()));
}
else
{
if (emo >= '0' && emo <= '9')
emoteId = CAST_U8(emo - '0' + 1);
else if (emo >= 'a' && emo <= 'z')
emoteId = CAST_U8(emo - 'a' + 11);
else if (emo >= 'A' && emo <= 'Z')
emoteId = CAST_U8(emo - 'A' + 37);
}
if (mMoveProgram[settings.crazyMoveState - 1] == 'e')
LocalPlayer::emote(emoteId);
else if (PacketLimiter::limitPackets(PacketType::PACKET_CHAT))
petHandler->emote(emoteId);
settings.crazyMoveState ++;
}
void BeingCommon::readWalkingAttributes(BeingInfo *const info,
XmlNodePtrConst node,
const int moreBlockFlags)
{
uint8_t block = 0;
std::string walkStr = XML::getProperty(
node, "walkType", "walk");
const uint8_t allFlags = CAST_U8(
BlockMask::GROUND |
BlockMask::WALL |
BlockMask::WATER |
BlockMask::AIR |
moreBlockFlags);
StringVect tokens;
splitToStringVector(tokens, walkStr, ',');
FOR_EACH (StringVectCIter, it, tokens)
{
if (walkStr == "walk" || walkStr == "ground")
block |= BlockMask::GROUND;
else if (walkStr == "fly" || walkStr == "air")
block |= BlockMask::GROUND | BlockMask::WATER | BlockMask::AIR;
else if (walkStr == "all")
block |= allFlags;
else if (walkStr == "wall")
block |= BlockMask::WALL;
else if (walkStr == "monsterwall")
block |= BlockMask::MONSTERWALL;
else if (walkStr == "swim" || walkStr == "water")
block |= BlockMask::WATER;
else if (walkStr == "walkswim" || walkStr == "swimwalk") // legacy
block |= BlockMask::GROUND | BlockMask::WATER;
}
info->setBlockWalkMask(CAST_U8(block ^ allFlags));
}
PxBounds3 RTree::refitAll(CallbackRefit& cb)
{
PxU8* treeNodes8 = PX_IS_X64 ? CAST_U8(get64BitBasePage()) : CAST_U8((mFlags & IS_DYNAMIC) ? NULL : mPages);
PxBounds3 meshBounds = refitRecursive(treeNodes8, 0, NULL, 0, cb);
for (PxU32 j = 1; j<mNumRootPages; j++)
meshBounds.include( refitRecursive(treeNodes8, j, NULL, 0, cb) );
#ifdef PX_CHECKED
validate(&cb);
#endif
return meshBounds;
}
void EmoteShortcut::load()
{
for (unsigned char i = 0, j = 0,
fsz = CAST_U8(EmoteDB::getLast());
i <= fsz && j < SHORTCUT_EMOTES;
i++)
{
const EmoteSprite *const sprite = EmoteDB::getSprite(i, true);
if (sprite != nullptr)
{
mEmotes[j] = CAST_U8(i + 1);
j ++;
}
}
}
void MessageOut::writeCoordinates(const uint16_t x,
const uint16_t y,
unsigned char direction,
const char *const str)
{
DEBUGLOG2(strprintf("writeCoordinates: %u,%u %u",
CAST_U32(x), static_cast<unsigned>(y),
CAST_U32(direction)), mPos, str);
unsigned char *const data = reinterpret_cast<unsigned char*>(mData)
+ CAST_SIZE(mPos);
mNetwork->mOutSize += 3;
mPos += 3;
uint16_t temp = x;
temp <<= 6;
data[0] = 0;
data[1] = 1;
data[2] = 2;
data[0] = HIBYTE(temp);
data[1] = CAST_U8(temp);
temp = y;
temp <<= 4;
data[1] |= HIBYTE(temp);
data[2] = LOBYTE(temp);
direction = toServerDirection(direction);
data[2] |= direction;
PacketCounters::incOutBytes(3);
}
void PlayerHandler::setDestination(const int x, const int y,
const int direction) const
{
createOutPacket(CMSG_PLAYER_CHANGE_DEST);
outMsg.writeCoordinates(CAST_U16(x),
CAST_U16(y),
CAST_U8(direction), "destination");
}
void EmoteShortcut::save() const
{
for (int i = 0; i < SHORTCUT_EMOTES; i++)
{
const unsigned char emoteId = mEmotes[i] != 0U ? mEmotes[i]
: CAST_U8(0);
serverConfig.setValue("emoteshortcut" + toString(i),
CAST_U32(emoteId));
}
}
const char *ipToString(const uint32_t address)
{
static char asciiIP[18];
snprintf(asciiIP, sizeof(asciiIP), "%i.%i.%i.%i",
CAST_U8(address),
CAST_U8(address >> 8),
CAST_U8(address >> 16),
CAST_U8(address >> 24));
asciiIP[17] = 0;
return asciiIP;
}
signed char MessageIn::readInt8(const char *const str)
{
signed char value = CAST_S8(-1);
if (mPos < mLength)
value = CAST_S8(mData[mPos]);
DEBUGLOG2("readInt8: " + toStringPrint(CAST_U32(
CAST_U8(value))),
mPos, str);
mPos += 1;
PacketCounters::incInBytes(1);
return value;
}
void BeingCommon::readBasicAttributes(BeingInfo *const info,
XmlNodePtrConst node,
const std::string &hoverCursor)
{
info->setTargetCursorSize(XML::getProperty(node,
"targetCursor", "medium"));
info->setHoverCursor(XML::getProperty(node, "hoverCursor", hoverCursor));
info->setTargetOffsetX(XML::getProperty(node, "targetOffsetX", 0));
info->setTargetOffsetY(XML::getProperty(node, "targetOffsetY", 0));
info->setNameOffsetX(XML::getProperty(node, "nameOffsetX", 0));
info->setNameOffsetY(XML::getProperty(node, "nameOffsetY", 0));
info->setSortOffsetY(XML::getProperty(node, "sortOffsetY", 0));
info->setHpBarOffsetX(XML::getProperty(node, "hpBarOffsetX", 0));
info->setHpBarOffsetY(XML::getProperty(node, "hpBarOffsetY", 0));
info->setQuickActionEffectId(XML::getProperty(node,
"quickActionEffect", -1));
unsigned char block = 0;
std::string walkStr = XML::getProperty(
node, "walkType", "walk");
const int allFlags = BlockMask::GROUND |
BlockMask::WALL |
BlockMask::WATER |
BlockMask::AIR;
StringVect tokens;
splitToStringVector(tokens, walkStr, ',');
FOR_EACH (StringVectCIter, it, tokens)
{
if (walkStr == "walk" || walkStr == "ground")
block |= BlockMask::GROUND;
else if (walkStr == "fly" || walkStr == "air")
block |= BlockMask::GROUND | BlockMask::WATER | BlockMask::AIR;
else if (walkStr == "all")
block |= allFlags;
else if (walkStr == "wall")
block |= BlockMask::WALL;
else if (walkStr == "swim" || walkStr == "water")
block |= BlockMask::WATER;
else if (walkStr == "walkswim" || walkStr == "swimwalk") // legacy
block |= BlockMask::GROUND | BlockMask::WATER;
}
info->setBlockWalkMask(CAST_U8(block ^ allFlags));
}
void GuildRecv::processGuildMemberList(Net::MessageIn &msg)
{
if (actorManager == nullptr)
return;
const int length = msg.readInt16("len");
if (length < 4)
return;
int guildSize = 0;
if (msg.getVersion() >= 20161026)
{
guildSize = 34;
}
else
{
guildSize = 104;
}
const int count = (length - 4) / guildSize;
if (taGuild == nullptr)
{
logger->log1("!taGuild");
return;
}
taGuild->clearMembers();
int onlineNum = 0;
int totalNum = 0;
for (int i = 0; i < count; i++)
{
const BeingId id = msg.readBeingId("account id");
const int charId = msg.readInt32("char id");
msg.readInt16("hair");
msg.readInt16("hair color");
const int gender = msg.readInt16("gender");
const int race = msg.readInt16("class");
const int level = msg.readInt16("level");
const int exp = msg.readInt32("exp");
const int online = msg.readInt32("online");
const int pos = msg.readInt32("position");
std::string name;
if (msg.getVersion() < 20161026)
{
msg.skip(50, "unused");
name = msg.readString(24, "name");
}
else
{
msg.readInt32("last login"); // for now unused
name = actorManager->findCharById(charId);
if (name.empty())
{
beingHandler->requestNameByCharId(charId);
}
}
GuildMember *const m = taGuild->addMember(id, charId, name);
if (m != nullptr)
{
m->setOnline(online != 0);
m->setID(id);
m->setCharId(charId);
m->setGender(Being::intToGender(CAST_U8(gender)));
m->setLevel(level);
m->setExp(exp);
m->setPos(pos);
m->setRace(race);
Being *const being = actorManager->findBeingByName(
name, ActorType::Player);
if (being != nullptr)
{
being->setGuildName(taGuild->getName());
if (being->getLevel() != level)
{
being->setLevel(level);
being->updateName();
}
}
if (online != 0)
onlineNum ++;
totalNum ++;
}
}
taGuild->sort();
actorManager->updatePlayerGuild();
actorManager->updatePlayerColors();
if (socialWindow != nullptr)
socialWindow->updateGuildCounter(onlineNum, totalNum);
}
void RegisterDialog::action(const ActionEvent &event)
{
const std::string &eventId = event.getId();
if (eventId == "cancel")
{
close();
}
else if (eventId == "register" && canSubmit())
{
const std::string &user = mUserField->getText();
logger->log("RegisterDialog::register Username is %s", user.c_str());
std::string errorMsg;
int error = 0;
const unsigned int minUser = loginHandler->getMinUserNameLength();
const unsigned int maxUser = loginHandler->getMaxUserNameLength();
const unsigned int minPass = loginHandler->getMinPasswordLength();
const unsigned int maxPass = loginHandler->getMaxPasswordLength();
if (user.length() < minUser)
{
// Name too short
errorMsg = strprintf
// TRANSLATORS: error message
(_("The username needs to be at least %u characters long."),
minUser);
error = 1;
}
else if (user.length() > maxUser - 1)
{
// Name too long
errorMsg = strprintf
// TRANSLATORS: error message
(_("The username needs to be less than %u characters long."),
maxUser);
error = 1;
}
else if (mPasswordField->getText().length() < minPass)
{
// Pass too short
errorMsg = strprintf
// TRANSLATORS: error message
(_("The password needs to be at least %u characters long."),
minPass);
error = 2;
}
else if (mPasswordField->getText().length() > maxPass)
{
// Pass too long
errorMsg = strprintf
// TRANSLATORS: error message
(_("The password needs to be less than %u characters long."),
maxPass);
error = 2;
}
else if (mPasswordField->getText() != mConfirmField->getText())
{
// Password does not match with the confirmation one
// TRANSLATORS: error message
errorMsg = _("Passwords do not match.");
error = 2;
}
else if (mEmailField &&
mEmailField->getText().find('@') == std::string::npos)
{
// TRANSLATORS: error message
errorMsg = _("Incorrect email.");
error = 1;
}
else if (mEmailField && mEmailField->getText().size() > 40)
{
// TRANSLATORS: error message
errorMsg = _("Email too long.");
error = 1;
}
if (error > 0)
{
if (error == 1)
{
mWrongDataNoticeListener->setTarget(this->mUserField);
}
else if (error == 2)
{
// Reset password confirmation
mPasswordField->setText("");
mConfirmField->setText("");
mWrongDataNoticeListener->setTarget(this->mPasswordField);
}
OkDialog *const dlg = CREATEWIDGETR(OkDialog,
// TRANSLATORS: error message
_("Error"), errorMsg, _("OK"),
DialogType::ERROR,
Modal_true,
ShowCenter_true,
nullptr,
260);
dlg->addActionListener(mWrongDataNoticeListener);
}
else
{
// No errors detected, register the new user.
mRegisterButton->setEnabled(false);
mLoginData->username = mUserField->getText();
mLoginData->password = mPasswordField->getText();
if (features.getIntValue("forceAccountGender") == -1)
{
if (mFemaleButton && mFemaleButton->isSelected())
mLoginData->gender = Gender::FEMALE;
else if (mOtherButton && mOtherButton->isSelected())
mLoginData->gender = Gender::OTHER;
else
mLoginData->gender = Gender::MALE;
}
else
{
mLoginData->gender = Being::intToGender(
CAST_U8(features.getIntValue("forceAccountGender")));
}
if (mEmailField)
mLoginData->email = mEmailField->getText();
mLoginData->registerLogin = true;
client->setState(State::REGISTER_ATTEMPT);
}
}
}
void LoginRecv::processLoginData(Net::MessageIn &msg)
{
msg.readInt16("len");
loginHandler->clearWorlds();
int offset = 0;
int serverLen = 0;
if (msg.getVersion() >= 20170315)
{
offset = 47 + 17;
serverLen = 32 + 128;
}
else
{
offset = 47;
serverLen = 32;
}
const int worldCount = (msg.getLength() - offset) / serverLen;
Ea::LoginRecv::mToken.session_ID1 = msg.readInt32("session id1");
Ea::LoginRecv::mToken.account_ID = msg.readBeingId("accound id");
Ea::LoginRecv::mToken.session_ID2 = msg.readInt32("session id2");
msg.readInt32("old ip");
loginData.lastLogin = msg.readString(24, "last login");
msg.readInt16("unused");
// reserve bits for future usage
Ea::LoginRecv::mToken.sex = Being::intToGender(CAST_U8(
msg.readUInt8("gender") & 3U));
if (msg.getVersion() >= 20170315)
{
msg.readString(16, "twitter auth token");
msg.readUInt8("twitter flag");
}
for (int i = 0; i < worldCount; i++)
{
WorldInfo *const world = new WorldInfo;
world->address = msg.readInt32("ip address");
world->port = msg.readInt16("port");
world->name = msg.readString(20, "name");
world->online_users = msg.readInt16("online number");
config.setValue("updatehost", Ea::LoginRecv::mUpdateHost);
world->updateHost = Ea::LoginRecv::mUpdateHost;
msg.readInt16("maintenance");
msg.readInt16("new");
if (msg.getVersion() >= 20170315)
{
for (int f = 0; f < 32; f ++)
msg.readInt32("unused2");
}
logger->log("Network: Server: %s (%s:%d)", world->name.c_str(),
ipToString(world->address), world->port);
Ea::LoginRecv::mWorlds.push_back(world);
}
client->setState(State::WORLD_SELECT);
}
}
void MessageIn::readCoordinates(uint16_t &restrict x,
uint16_t &restrict y,
uint8_t &restrict direction,
const char *const str)
{
if (mPos + 3 <= mLength)
{
const char *const data = mData + CAST_SIZE(mPos);
uint16_t temp = MAKEWORD(data[1] & 0x00c0, data[0] & 0x00ff);
x = CAST_U16(temp >> 6);
temp = MAKEWORD(data[2] & 0x00f0, data[1] & 0x003f);
y = CAST_U16(temp >> 4);
const uint8_t serverDir = CAST_U8(data[2] & 0x000f);
direction = fromServerDirection(serverDir);
DEBUGLOG2(std::string("readCoordinates: ").append(toString(
CAST_S32(x))).append(",").append(toString(
CAST_S32(y))).append(",").append(toString(
CAST_S32(serverDir))), mPos, str);
}
else
{
x = 0;
y = 0;
direction = 0;
logger->log("error: wrong readCoordinates packet");
}
mPos += 3;
void RTree::refitAllStaticTree(CallbackRefit& cb, PxBounds3* retBounds)
{
PxU8* treeNodes8 = PX_IS_X64 ? CAST_U8(get64BitBasePage()) : CAST_U8((mFlags & IS_DYNAMIC) ? NULL : mPages);
// since pages are ordered we can scan back to front and the hierarchy will be updated
for (PxI32 iPage = PxI32(mTotalPages)-1; iPage>=0; iPage--)
{
RTreePage& page = mPages[iPage];
for (PxU32 j = 0; j < RTREE_PAGE_SIZE; j++)
{
if (page.isEmpty(j))
continue;
if (page.isLeaf(j))
{
Vec3V childMn, childMx;
cb.recomputeBounds(page.ptrs[j]-1, childMn, childMx); // compute the bound around triangles
PxVec3 mn3, mx3;
V3StoreU(childMn, mn3);
V3StoreU(childMx, mx3);
page.minx[j] = mn3.x; page.miny[j] = mn3.y; page.minz[j] = mn3.z;
page.maxx[j] = mx3.x; page.maxy[j] = mx3.y; page.maxz[j] = mx3.z;
} else
{
const RTreePage* child = (const RTreePage*)(treeNodes8 + page.ptrs[j]);
PX_COMPILE_TIME_ASSERT(RTREE_PAGE_SIZE == 4);
bool first = true;
for (PxU32 k = 0; k < RTREE_PAGE_SIZE; k++)
{
if (child->isEmpty(k))
continue;
if (first)
{
page.minx[j] = child->minx[k]; page.miny[j] = child->miny[k]; page.minz[j] = child->minz[k];
page.maxx[j] = child->maxx[k]; page.maxy[j] = child->maxy[k]; page.maxz[j] = child->maxz[k];
first = false;
} else
{
page.minx[j] = PxMin(page.minx[j], child->minx[k]);
page.miny[j] = PxMin(page.miny[j], child->miny[k]);
page.minz[j] = PxMin(page.minz[j], child->minz[k]);
page.maxx[j] = PxMax(page.maxx[j], child->maxx[k]);
page.maxy[j] = PxMax(page.maxy[j], child->maxy[k]);
page.maxz[j] = PxMax(page.maxz[j], child->maxz[k]);
}
}
}
}
}
if (retBounds)
{
RTreeNodeQ bound1;
for (PxU32 ii = 0; ii<mNumRootPages; ii++)
{
mPages[ii].computeBounds(bound1);
if (ii == 0)
{
retBounds->minimum = PxVec3(bound1.minx, bound1.miny, bound1.minz);
retBounds->maximum = PxVec3(bound1.maxx, bound1.maxy, bound1.maxz);
} else
{
retBounds->minimum = retBounds->minimum.minimum(PxVec3(bound1.minx, bound1.miny, bound1.minz));
retBounds->maximum = retBounds->maximum.maximum(PxVec3(bound1.maxx, bound1.maxy, bound1.maxz));
}
}
}
#ifdef PX_CHECKED
validate(&cb);
#endif
}
