3a426d5297
Batch #9287 by secret: 0 byte-identical, 6 confirmed by peer review. - fn_21337 CGameMode::ProcessRightButtonDrag: logic confirmed by peer review - fn_21339 CGameMode::ProcessMouseWheel: logic confirmed by peer review - fn_21409 CGameMode::EnsureBroadcastBalloon: logic confirmed by peer review (already on main) - fn_21311 CGameMode::EnsureNameBalloon: logic confirmed by peer review (already on main) - fn_21315 OpenWordDisplay: logic confirmed by peer review (already on main) - fn_21435 CGameMode::ShowNoticeBalloon: logic confirmed by peer review (already on main) Peer-reviewed-by: KWDev, SapitoSucio, Bielhp, superintelligence, gordaoprogramas, Tanke, dori, youko Accepted without human review: peers confirmed the logic ("same" ahead by at least 3, with 70% of the votes).
3813 lines
118 KiB
C++
3813 lines
118 KiB
C++
#include "Client/Mode/CGameMode.h"
|
|
#include "Client/Mode/ModeMgr.h"
|
|
#include "Client/Replay.h"
|
|
#include "Client/ReplayPacketRecorder.h"
|
|
#include "Client/Session.h"
|
|
#include "Contents/Actors/GameActor.h"
|
|
#include "Contents/Actors/Pc.h"
|
|
#include "Contents/Camera/Camera.h"
|
|
#include "Contents/Configuration/ServiceConfiguration.h"
|
|
#include "Contents/Configuration/ServiceOptions.h"
|
|
#include "Contents/Effects/DummyEffectLauncher.h"
|
|
#include "Contents/Effects/EffectLists.h"
|
|
#include "Contents/Effects/SkillEffects.h"
|
|
#include "Contents/Effects/RagEffect.h"
|
|
#include "Contents/GuildInfo.h"
|
|
#include "Contents/GuildMgr.h"
|
|
#include "Contents/MessageTable.h"
|
|
#include "Contents/Actors/MousePointer.h"
|
|
#include "Contents/Actors/RenderObject.h"
|
|
#include "Contents/Items/ItemInfo.h"
|
|
#include "Contents/PlayerNameDictionary.h"
|
|
#include "Contents/Skills/ClientSkills.h"
|
|
#include "Contents/Skills/SkillInfo.h"
|
|
#include "Contents/Sound/SoundMgr.h"
|
|
#include "Contents/World/World.h"
|
|
#include "Network/Connection/Connection.h"
|
|
#include "Network/Packets/PacketLengths.h"
|
|
#include "Render/Renderer.h"
|
|
#include "Resource/World/TerrainResource.h"
|
|
#include "Script/LuaScript.h"
|
|
#include "UI/UIBroadcastBalloon.h"
|
|
#include "UI/Chat/ChatSuggestions.h"
|
|
#include "UI/Window/UIWindow.h"
|
|
#include "UI/Window/UIWindowMgr.h"
|
|
#include "UI/Window/WindowDialogs.h"
|
|
#include "Utility/Math/Vector3d.h"
|
|
#include "Utility/Text/FormatString.h"
|
|
#include "Client/Application/Launcher.h"
|
|
#include "UI/Text/NavigationLink.h"
|
|
#include "Contents/RenewQuestMgr.h"
|
|
#include "Client/Mode/ModeCursor.h"
|
|
#include "Contents/Skills/AutomaticSkills.h"
|
|
#include "UI/Shortcuts/UIShortCutWnd.h"
|
|
#include "Contents/MapInfoMgr.h"
|
|
#include <timeapi.h>
|
|
#include "File/File.h"
|
|
#pragma pack(push, 1)
|
|
struct GameModeTextRecord {
|
|
/* 0000 */ std::uint32_t header;
|
|
/* 0004 */ std::int16_t length;
|
|
/* 0006 */ int firstLength;
|
|
/* 000A */ int secondLength;
|
|
/* 000E */ int unknown_000E;
|
|
/* 0012 */ int unknown_0012;
|
|
/* 0016 */ int unknown_0016;
|
|
/* 001A */ int unknown_001A;
|
|
/* 001E */ char buffer[0x172];
|
|
};
|
|
#pragma pack(pop)
|
|
|
|
#pragma pack(push, 1)
|
|
struct GameModeReplayPacket {
|
|
/* 0000 */ std::uint32_t header;
|
|
/* 0004 */ std::uint16_t length;
|
|
/* 0006 */ unsigned char info[0x19];
|
|
/* 001F */ unsigned char data[0xDF];
|
|
};
|
|
#pragma pack(pop)
|
|
|
|
static_assert(sizeof(GameModeReplayPacket) == 0xFE);
|
|
|
|
static_assert(sizeof(GameModeTextRecord) == 0x190);
|
|
static_assert(offsetof(GameModeTextRecord, buffer) == 0x1E);
|
|
|
|
// GLOBAL: gl_24661
|
|
std::vector<ActiveSkillEffect> g_activeSkillEffects;
|
|
|
|
// OFFSET: 0x00CCF480
|
|
// FUNCTION: fn_21242
|
|
void CGameMode::PushUnknown01A4(int value) {
|
|
this->unknown_01A4.push_back(value);
|
|
}
|
|
|
|
// OFFSET: 0x00CCF530
|
|
// FUNCTION: fn_21243
|
|
bool CGameMode::IsOverWeight(bool notify) {
|
|
int maxWeight = g_session.m_maxWeight;
|
|
if (maxWeight < 1) {
|
|
maxWeight = 1;
|
|
}
|
|
|
|
if (g_session.m_weight * 100 / maxWeight < 90) {
|
|
return false;
|
|
}
|
|
|
|
if (notify) {
|
|
g_windowMgr.SendNotice(3, 0, 0, 0, 0, 0);
|
|
g_windowMgr.SendNotice(1, reinterpret_cast<std::intptr_t>(LookupMessage(307)), 255, 0, 0, 0);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// OFFSET: 0x00CCFCF0
|
|
// FUNCTION: fn_21247
|
|
void CGameMode::CompleteUnknown0194(std::uint32_t id, const std::string& text) {
|
|
auto it = this->unknown_0194.find(id);
|
|
if (it != this->unknown_0194.end()) {
|
|
this->SendMsg(140, reinterpret_cast<int>(text.c_str()), it->second, 0, 0);
|
|
this->unknown_0194.erase(it);
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00CD52F0
|
|
// FUNCTION: fn_21279
|
|
int CGameMode::GetSkillAttackRange(int id, int level) {
|
|
if (id == 10000) {
|
|
return 5;
|
|
}
|
|
|
|
int range = 1;
|
|
CSkillInfo skill = reinterpret_cast<const ClientSkills&>(g_session).Lookup(id);
|
|
if (!skill.available) {
|
|
skill = g_session.m_skillBundle.Pending(id);
|
|
if (!skill.available) {
|
|
return range;
|
|
}
|
|
|
|
level = skill.level;
|
|
}
|
|
|
|
int reduction = 0;
|
|
g_luaScript->Call("GetSkillAttackRange", "ddd>dd", id, level, skill.level, &range, &reduction);
|
|
range += skill.unknown_001C - reduction;
|
|
return range;
|
|
}
|
|
|
|
// OFFSET: 0x00CD54D0
|
|
// FUNCTION: fn_21280
|
|
int CGameMode::TerrainHeight() const {
|
|
if (!this->scene || !this->scene->terrain) {
|
|
return 0;
|
|
}
|
|
|
|
return this->scene->terrain->height;
|
|
}
|
|
|
|
// OFFSET: 0x00CD54F0
|
|
// FUNCTION: fn_21281
|
|
int CGameMode::TerrainWidth() const {
|
|
if (!this->scene || !this->scene->terrain) {
|
|
return 0;
|
|
}
|
|
|
|
return this->scene->terrain->width;
|
|
}
|
|
|
|
// OFFSET: 0x00CD5550
|
|
// FUNCTION: fn_21283
|
|
std::string CGameMode::LocationText() {
|
|
char text[120];
|
|
std::memset(text, 0, sizeof(text));
|
|
|
|
int column;
|
|
int row;
|
|
const auto* player = reinterpret_cast<const CRenderObject*>(this->scene->player);
|
|
this->WorldCell(player->render.position.x, player->render.position.z, column, row);
|
|
|
|
std::string name = this->mapName;
|
|
if (name.size() > 4) {
|
|
name.resize(name.size() - 4);
|
|
}
|
|
|
|
std::sprintf(text, "Location: %s ( %d , %d )", name.c_str(), column, row);
|
|
return text;
|
|
}
|
|
|
|
// OFFSET: 0x00CD5800
|
|
// FUNCTION: fn_21284
|
|
bool CGameMode::HasInventoryItem(int id) {
|
|
const ITEM_INFO item = LookupClientItem(g_session.m_inventoryItems, id, 0);
|
|
return item.unknown_0000[1] != 0 && item.quantity > 0;
|
|
}
|
|
|
|
// OFFSET: 0x00CD58B0
|
|
// FUNCTION: fn_21285
|
|
bool CGameMode::HasResurrectionItem() {
|
|
ITEM_INFO item = LookupClientItem(g_session.m_inventoryItems, 7621, 0);
|
|
const CWorld* world = this->scene;
|
|
if (world->unknown_0048 || world->unknown_004C || world->unknown_0054) {
|
|
return false;
|
|
}
|
|
|
|
if (item.unknown_0000[1] != 0 && item.quantity > 0) {
|
|
return true;
|
|
}
|
|
|
|
item = LookupClientItem(g_session.m_inventoryItems, 6833, 0);
|
|
if (item.unknown_0000[1] != 0 && item.quantity > 0) {
|
|
return true;
|
|
}
|
|
|
|
item = LookupClientItem(g_session.m_inventoryItems, 6316, 0);
|
|
if (item.unknown_0000[1] != 0 && item.quantity > 0) {
|
|
return true;
|
|
}
|
|
|
|
item = LookupClientItem(g_session.m_inventoryItems, 6293, 0);
|
|
if (item.unknown_0000[1] != 0 && item.quantity > 0) {
|
|
return true;
|
|
}
|
|
|
|
item = LookupClientItem(g_session.m_inventoryItems, 25310, 0);
|
|
if (item.unknown_0000[1] != 0 && item.quantity > 0) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// OFFSET: 0x00CD5CD0
|
|
// FUNCTION: fn_21287
|
|
void CGameMode::SendMousePointerState(int value) {
|
|
if (this->mousePointer) {
|
|
this->mousePointer->SendMsg(nullptr, 2, 0, value, value >> 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00CECE00
|
|
// FUNCTION: fn_21360
|
|
void CGameMode::ClearUnknown0458() {
|
|
*reinterpret_cast<int*>(reinterpret_cast<char*>(this) + 0x458) = 0;
|
|
}
|
|
|
|
// OFFSET: 0x00CECE10
|
|
// FUNCTION: fn_21361
|
|
void CGameMode::SetDragIds(int source, int id) {
|
|
if (id != -1) {
|
|
this->drag.source = source;
|
|
this->drag.id = static_cast<std::uint32_t>(id);
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00CED190
|
|
// FUNCTION: fn_21363
|
|
void CGameMode::UpdateUnknown0628(int id, bool add) {
|
|
if (add == true) {
|
|
this->unknown_0628.insert(id);
|
|
} else {
|
|
this->unknown_0628.erase(id);
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00CEFFC0
|
|
|
|
// OFFSET: 0x00CF0070
|
|
// FUNCTION: fn_21410
|
|
const char* CGameMode::Unknown04DCText() {
|
|
return reinterpret_cast<std::string*>(reinterpret_cast<char*>(this) + 0x4DC)->c_str();
|
|
}
|
|
|
|
// OFFSET: 0x00CF0320
|
|
// FUNCTION: fn_21412
|
|
CPlayer* CGameMode::Player() {
|
|
if (!this->scene) {
|
|
return nullptr;
|
|
}
|
|
return this->scene->player;
|
|
}
|
|
|
|
// OFFSET: 0x00CF0330
|
|
// FUNCTION: fn_21413
|
|
MinimapMarker* CGameMode::FindMinimapMarker(std::uint32_t key) {
|
|
const auto it = this->minimapMarkers.find(key);
|
|
if (it == this->minimapMarkers.end()) {
|
|
return nullptr;
|
|
}
|
|
return &it->second;
|
|
}
|
|
|
|
// OFFSET: 0x00CF05E0
|
|
// FUNCTION: fn_21415
|
|
std::string CGameMode::GetUnknown0084(unsigned int index) {
|
|
if (!this->unknown_0084.empty() && index <= this->unknown_0084.size()) {
|
|
return this->unknown_0084[index];
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
// OFFSET: 0x00CF06B0
|
|
// FUNCTION: fn_21416
|
|
float CGameMode::CameraDesiredYaw() {
|
|
if (!this->camera) {
|
|
return 0.0f;
|
|
}
|
|
return this->camera->camera.desiredYaw;
|
|
}
|
|
|
|
// OFFSET: 0x00CF0380
|
|
// FUNCTION: fn_21414
|
|
std::string CGameMode::GetActiveSkillEffectTimeText(int skillId, int* activeSkillId) {
|
|
std::string output;
|
|
*activeSkillId = skillId;
|
|
|
|
for (const ActiveSkillEffect& effect : g_activeSkillEffects) {
|
|
const int effectId = static_cast<int>(effect.id);
|
|
if (skillId != (effectId == 0x2A ? 0x0C : effectId)) {
|
|
continue;
|
|
}
|
|
|
|
*activeSkillId = effectId;
|
|
const std::uint32_t expiration = effect.unknown_0004;
|
|
if (expiration == 999999 || expiration == 0) {
|
|
return output;
|
|
}
|
|
|
|
std::uint32_t remainingSeconds = 0;
|
|
if (g_replayAnimationScaling == 0) {
|
|
remainingSeconds = (expiration - timeGetTime()) / 1000;
|
|
} else {
|
|
const int remainingMilliseconds = static_cast<int>(expiration) - static_cast<int>(Replay::Instance().elapsed);
|
|
if (remainingMilliseconds >= 1000) {
|
|
remainingSeconds = static_cast<std::uint32_t>(remainingMilliseconds) / 1000;
|
|
}
|
|
}
|
|
|
|
const int signedSeconds = static_cast<int>(remainingSeconds);
|
|
const int hours = signedSeconds / 3600;
|
|
if (hours != 0) {
|
|
output.append(FormatOwnedString("%d %s", hours, LookupMessage(0x6A1)));
|
|
}
|
|
|
|
const int remainder = signedSeconds - hours * 3600;
|
|
const int minutes = remainder / 60;
|
|
const int seconds = remainder % 60;
|
|
if (minutes != 0) {
|
|
output.append(FormatOwnedString(" %d %s", minutes, LookupMessage(0x70F)));
|
|
}
|
|
if (seconds != 0) {
|
|
output.append(FormatOwnedString(" %d %s", seconds, LookupMessage(0x710)));
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
return output;
|
|
}
|
|
|
|
// OFFSET: 0x00CF0A80
|
|
// FUNCTION: fn_21420
|
|
bool CGameMode::IsActiveSkillEffectId(std::uint32_t id) {
|
|
if (this->IsExcludedSkillEffectId(id)) {
|
|
return false;
|
|
}
|
|
|
|
for (const ActiveSkillEffect& effect : g_activeSkillEffects) {
|
|
if (effect.id == id) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// OFFSET: 0x00D07720
|
|
// FUNCTION: fn_21582
|
|
bool CGameMode::IsExcludedSkillEffectId(std::uint32_t id) {
|
|
return id == 0x28 || id == 0x2A;
|
|
}
|
|
|
|
// OFFSET: 0x00D07740
|
|
// FUNCTION: fn_21583
|
|
int CGameMode::SubD07740(int id, int defaultResult) {
|
|
if (id < 0xFB5) {
|
|
if (id == 0xFB4 || id == 0x13) {
|
|
return 1;
|
|
}
|
|
|
|
if (id == 0x14) {
|
|
return 0;
|
|
}
|
|
} else {
|
|
switch (id) {
|
|
case 0xFB5:
|
|
case 0xFCB:
|
|
case 0xFE5:
|
|
case 0xFEC:
|
|
case 0x1009:
|
|
case 0x10A8:
|
|
return 0;
|
|
case 0xFCA:
|
|
case 0xFE4:
|
|
case 0xFEB:
|
|
case 0x1008:
|
|
case 0x10A7:
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return defaultResult;
|
|
}
|
|
|
|
// OFFSET: 0x00CEB8E0
|
|
// FUNCTION: fn_21352
|
|
void CGameMode::sub_CEB8E0() {
|
|
if (Replay::Instance().state != 2) {
|
|
return;
|
|
}
|
|
|
|
GameModeTextRecord record = {};
|
|
record.header = 0x038808AE;
|
|
record.firstLength = static_cast<int>(this->unknown_03C8.size());
|
|
record.secondLength = static_cast<int>(this->unknown_03E0.size());
|
|
record.unknown_000E = this->unknown_03F8;
|
|
record.unknown_0012 = this->unknown_03FC;
|
|
record.unknown_0016 = this->unknown_0400;
|
|
record.unknown_001A = this->unknown_0404;
|
|
|
|
std::memcpy(record.buffer, this->unknown_03C8.data(), record.firstLength);
|
|
std::memcpy(record.buffer + record.firstLength, this->unknown_03E0.data(), record.secondLength);
|
|
record.length = static_cast<std::int16_t>(offsetof(GameModeTextRecord, buffer) + record.firstLength + record.secondLength);
|
|
|
|
Replay& replay = Replay::Instance();
|
|
ReplayPacketRecorder recorder = {
|
|
g_packetLengths,
|
|
replay.baseFrame,
|
|
replay.started,
|
|
replay.frame,
|
|
replay.header.key0,
|
|
replay.header.key1,
|
|
replay.header.options.recordRestricted,
|
|
replay.file,
|
|
replay.fileOffset,
|
|
replay.records,
|
|
replay.cipherIndex,
|
|
replay.cipherBase,
|
|
replay.cipherKey,
|
|
};
|
|
recorder.Record(static_cast<std::uint16_t>(record.length), &record, 0x2A, 0);
|
|
}
|
|
|
|
// OFFSET: 0x00CEBF30
|
|
|
|
// OFFSET: 0x00CEC100
|
|
|
|
// OFFSET: 0x00CEC6A0
|
|
// FUNCTION: fn_21356
|
|
unsigned CGameMode::sub_CEC6A0(const std::vector<unsigned char>& data) {
|
|
if (data.empty()) {
|
|
return 0xFFFFFFFFu;
|
|
}
|
|
|
|
unsigned offset = 6;
|
|
if (*reinterpret_cast<const std::int16_t*>(data.data()) == 17000) {
|
|
while (offset < data.size()) {
|
|
const short type = *reinterpret_cast<const short*>(data.data() + offset);
|
|
const std::uint32_t size = *reinterpret_cast<const std::uint32_t*>(data.data() + offset + 2);
|
|
offset += 6;
|
|
|
|
if (type == 0xCD) {
|
|
unsigned char* record = new unsigned char[0x10]();
|
|
std::memcpy(record, data.data() + offset, size);
|
|
offset += size;
|
|
this->sub_D41250(record);
|
|
delete[] record;
|
|
} else if (type == 0xCE) {
|
|
unsigned char* record = new unsigned char[0x61]();
|
|
std::memcpy(record, data.data() + offset, size);
|
|
offset += size;
|
|
this->sub_D40730(record);
|
|
delete[] record;
|
|
} else if (type == 0x4269) {
|
|
break;
|
|
} else {
|
|
offset += size;
|
|
}
|
|
}
|
|
} else {
|
|
offset = 0xFFFFFFFFu;
|
|
}
|
|
|
|
return offset;
|
|
}
|
|
|
|
// OFFSET: 0x00CEFE50
|
|
// FUNCTION: fn_21407
|
|
void CGameMode::ClearUnknown04DC() {
|
|
this->unknown_04DC.assign("", 0);
|
|
}
|
|
|
|
// GLOBAL: gl_24846
|
|
int g_followUpdateTick;
|
|
|
|
// GLOBAL: gl_24847
|
|
int g_followLostTick;
|
|
|
|
// OFFSET: 0x00CECB60
|
|
// FUNCTION: fn_21358
|
|
void CGameMode::SetFollowTicks(int updateTick, int lostTick) {
|
|
g_followUpdateTick = updateTick != -1 ? updateTick : g_followUpdateTick;
|
|
g_followLostTick = lostTick != -1 ? lostTick : g_followLostTick;
|
|
}
|
|
|
|
// OFFSET: 0x00CF0AC0
|
|
// FUNCTION: fn_21421
|
|
bool CGameMode::IsMenuWindowOpen() const {
|
|
return g_windowMgr.LookupWindow(0x122) != nullptr || g_windowMgr.LookupWindow(0x12E) != nullptr
|
|
|| g_windowMgr.LookupWindow(0x15C) != nullptr || g_windowMgr.LookupWindow(0x2716) != nullptr
|
|
|| g_windowMgr.LookupWindow(0x169) != nullptr;
|
|
}
|
|
|
|
// OFFSET: 0x00CF0B30
|
|
// FUNCTION: fn_21422
|
|
bool CGameMode::ShowRestrictedNotice(int grade) {
|
|
if (g_serviceMode == 3 || g_serviceType == 10 || grade < 2) {
|
|
return false;
|
|
}
|
|
|
|
g_windowMgr.SendNotice(3, 0, 0, 0, 0, 0);
|
|
g_windowMgr.SendNotice(1, reinterpret_cast<std::intptr_t>(LookupMessage(0x31)), 255, 0, 0, 0);
|
|
g_windowMgr.unknown_04DC.assign("", 0);
|
|
return true;
|
|
}
|
|
|
|
// OFFSET: 0x00CEFE70
|
|
// FUNCTION: fn_21408
|
|
void CGameMode::RemoveUnknown0604(int window) {
|
|
UIWindow* target = reinterpret_cast<UIWindow*>(window);
|
|
for (std::list<UIWindow*>::iterator it = this->unknown_0604.begin(); it != this->unknown_0604.end(); ++it) {
|
|
if (*it == target) {
|
|
this->unknown_0604.erase(it);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00CEFB30
|
|
// FUNCTION: fn_21404
|
|
void CGameMode::AddUnknown0604(UIWindow* window) {
|
|
this->unknown_0604.push_back(window);
|
|
}
|
|
|
|
#pragma pack(push, 1)
|
|
struct AdminStatusRequestPacket {
|
|
/* 0000 */ std::uint16_t id;
|
|
/* 0002 */ std::uint32_t accountId;
|
|
/* 0006 */ unsigned char unknown_0006;
|
|
/* 0007 */ std::uint16_t unknown_0007;
|
|
};
|
|
#pragma pack(pop)
|
|
static_assert(sizeof(AdminStatusRequestPacket) == 9);
|
|
|
|
// OFFSET: 0x00CEFCA0
|
|
// FUNCTION: fn_21405
|
|
void CGameMode::RequestAdminStatus() {
|
|
if (IsAdminAccount(g_session.m_aid)) {
|
|
return;
|
|
}
|
|
|
|
if (g_serviceMode == 3) {
|
|
return;
|
|
}
|
|
|
|
AdminStatusRequestPacket packet = {};
|
|
packet.id = 0x149;
|
|
packet.accountId = static_cast<std::uint32_t>(g_session.m_aid);
|
|
packet.unknown_0006 = 2;
|
|
packet.unknown_0007 = 0xA;
|
|
GetRagConnection().Send(g_packetLengths.FixedLength(packet.id), &packet);
|
|
}
|
|
|
|
// OFFSET: 0x00D06BD0
|
|
// FUNCTION: fn_21578
|
|
void SetPlayerName(std::uint32_t id, std::string name) {
|
|
g_playerNameDictionary->Set(id, name);
|
|
static_cast<CGameMode*>(g_modeMgr.GetGameMode())->CompleteUnknown0194(id, name);
|
|
GuildInfo* guildInfo = reinterpret_cast<GuildInfo*>(reinterpret_cast<char*>(&g_guildId) - offsetof(GuildInfo, m_guildId));
|
|
guildInfo->UpdateCharacterName(id, name.c_str());
|
|
g_session.NotifyUnknown7F94Name(id, name.c_str());
|
|
g_session.UpdateFriendName(id, name.c_str());
|
|
}
|
|
|
|
// OFFSET: 0x00CDD350
|
|
// FUNCTION: fn_21316
|
|
void CGameMode::PlaceWindowAtActor(UIWindow* window, CGameActor* actor) {
|
|
const int width = window->geometry.width;
|
|
const int height = window->geometry.height;
|
|
const bool raised = g_serviceOptions.Get(0x5C) != 0;
|
|
int offsetX = 0;
|
|
int offsetY = 0;
|
|
switch (actor->render.unknown_00A8 != 0 ? raised : 0) {
|
|
case 0:
|
|
offsetX = -(width / 2);
|
|
offsetY = static_cast<int>(static_cast<float>(g_renderer->viewport.height * 20 / 480) * actor->render.unknown_005C);
|
|
break;
|
|
case 1:
|
|
offsetX = -(width / 2);
|
|
offsetY = static_cast<int>(static_cast<float>(g_renderer->viewport.height * -100 / 480) * actor->render.unknown_005C);
|
|
break;
|
|
case 2:
|
|
offsetX = static_cast<int>(
|
|
static_cast<float>(g_renderer->viewport.width * -30 / 640) * actor->render.unknown_005C - static_cast<float>(width / 2)
|
|
);
|
|
offsetY = static_cast<int>(
|
|
static_cast<float>(g_renderer->viewport.height * -25 / 480) * actor->render.unknown_005C - static_cast<float>(height / 2)
|
|
);
|
|
break;
|
|
case 3:
|
|
offsetX = static_cast<int>(
|
|
static_cast<float>(g_renderer->viewport.width * 30 / 640) * actor->render.unknown_005C - static_cast<float>(width / 2)
|
|
);
|
|
offsetY = static_cast<int>(
|
|
static_cast<float>(g_renderer->viewport.height * -25 / 480) * actor->render.unknown_005C - static_cast<float>(height / 2)
|
|
);
|
|
break;
|
|
}
|
|
|
|
int x = actor->render.screenX + offsetX;
|
|
int y = actor->render.screenY + offsetY;
|
|
if (x < -3) {
|
|
x = -3;
|
|
}
|
|
const int maximumX = g_renderer->viewport.width - window->geometry.width + 3;
|
|
if (maximumX < x) {
|
|
x = maximumX;
|
|
}
|
|
if (y < -3) {
|
|
y = -3;
|
|
}
|
|
const int maximumY = g_renderer->viewport.height - window->geometry.height + 3;
|
|
if (maximumY < y) {
|
|
y = maximumY;
|
|
}
|
|
window->Move(x, y);
|
|
}
|
|
|
|
// OFFSET: 0x00CDD790
|
|
// FUNCTION: fn_21318
|
|
void CGameMode::Slot7(int value) {
|
|
}
|
|
|
|
// OFFSET: 0x00CDFA00
|
|
// FUNCTION: fn_21324
|
|
std::uint64_t CGameMode::LaunchDummyEffect(const vector3d* position, int effectId, int lifeFrames, int value) {
|
|
if (lifeFrames > 0) {
|
|
CDummyEffectLauncher* launcher = new CDummyEffectLauncher;
|
|
if (launcher != nullptr) {
|
|
const int address = reinterpret_cast<int>(position);
|
|
launcher->SendMsg(nullptr, 14, 0, address, address >> 31, effectId, effectId >> 31, lifeFrames, lifeFrames >> 31, value, value >> 31, 0, 0, 0, 0);
|
|
this->scene->objects.push_back(launcher);
|
|
return launcher->identity;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// OFFSET: 0x00CDFB00
|
|
// FUNCTION: fn_21326
|
|
void CGameMode::RequestPlayerAction(int target, int argument) {
|
|
int value = this->unknown_040C;
|
|
if (value != 10000) {
|
|
const int maxWeight = g_session.m_maxWeight < 1 ? 1 : g_session.m_maxWeight;
|
|
if (g_session.m_weight * 100 / maxWeight >= 90) {
|
|
g_windowMgr.SendNotice(3, 0, 0, 0, 0, 0);
|
|
g_windowMgr.SendNotice(1, reinterpret_cast<std::intptr_t>(LookupMessage(307)), 0xFF, 0, 0, 0);
|
|
value = this->unknown_040C;
|
|
if (value != 40000) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
switch (reinterpret_cast<std::intptr_t>(this->unknown_0408)) {
|
|
case 0:
|
|
this->scene->player->SendMsg(nullptr, 10, 0, target, 0, argument, argument >> 31, 0, 0, 0, 0, 0, 0, 0, 0);
|
|
break;
|
|
case 2:
|
|
case 4:
|
|
this->scene->player->SendMsg(nullptr, 41, 0, target, 0, value, value >> 31, 0, 0, 0, 0, 0, 0, 0, 0);
|
|
this->scene->player->SendMsg(nullptr, 90, 0, this->unknown_0414, this->unknown_0414 >> 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00CE45B0
|
|
// FUNCTION: fn_21336
|
|
void CGameMode::UpdateLoopSounds() {
|
|
for (std::vector<GameModeLoopSound>::iterator it = this->loopSounds.begin(); it != this->loopSounds.end(); ++it) {
|
|
timeGetTime();
|
|
if (timeGetTime() < it->nextTick) {
|
|
continue;
|
|
}
|
|
|
|
if (it->npcId) {
|
|
CRenderObject* actor = this->scene->GetGameActorByAID(it->npcId);
|
|
if (actor) {
|
|
CPlayer* player = this->scene->player;
|
|
g_soundMgr->PlayWave(it->name.c_str(), player->render.position.x - actor->render.position.x, 0.0f,
|
|
player->render.position.z - actor->render.position.z, 250, 40, 1.0f, 0);
|
|
}
|
|
} else {
|
|
g_soundMgr->PlayWave(it->name.c_str(), 0.0f, 0.0f, 0.0f, 250, 40, 1.0f, 0);
|
|
}
|
|
it->nextTick = timeGetTime() + it->term;
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00CE81C0
|
|
// FUNCTION: fn_21340
|
|
void CGameMode::AddSceneObject(CRenderObject* object) {
|
|
if (this->scene && object) {
|
|
this->scene->objects.push_back(object);
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00CED2E0
|
|
// FUNCTION: fn_21365
|
|
void CGameMode::SendMousePointerPosition(float x, float y, int value) {
|
|
float position[2];
|
|
position[0] = x;
|
|
position[1] = y;
|
|
const std::intptr_t address = reinterpret_cast<std::intptr_t>(position);
|
|
this->mousePointer->SendMsg(nullptr, 1, 0, address, address >> 31, value, value >> 31, 0, 0, 0, 0, 0, 0, 0, 0);
|
|
}
|
|
|
|
// OFFSET: 0x00CED330
|
|
// FUNCTION: fn_21366
|
|
void ShowCurrentMapName() {
|
|
if (g_serviceOptions.Get(0x10C)) {
|
|
const std::string mapName = g_session.m_navigationPlayerMap + std::string(".rsw");
|
|
g_mapInfoMgr->ShowMapName(mapName);
|
|
}
|
|
}
|
|
|
|
// GLOBAL: gl_25129
|
|
char g_chatLogPath[260];
|
|
|
|
// OFFSET: 0x00CED760
|
|
// FUNCTION: fn_21369
|
|
void CGameMode::WriteChatLog(const char* text) {
|
|
if (g_session.IsAdminSubMode(7) == 0) {
|
|
return;
|
|
}
|
|
|
|
++this->chatLogLines;
|
|
CFile previous;
|
|
previous.Open(g_chatLogPath, 0, true, false);
|
|
const std::uint32_t size = previous.GetSize();
|
|
char* contents = new char[size];
|
|
previous.Read(contents, size);
|
|
previous.Close();
|
|
g_whisperFile.Open(g_chatLogPath, 0x1001, true, false);
|
|
g_whisperFile.Write(contents, size);
|
|
g_whisperFile.Write(text, static_cast<std::uint32_t>(std::strlen(text) + 1));
|
|
g_whisperFile.Write("\r\n", 2);
|
|
g_whisperFile.Close();
|
|
delete[] contents;
|
|
}
|
|
|
|
// OFFSET: 0x00CF08D0
|
|
// FUNCTION: fn_21417
|
|
bool CGameMode::IsEffectId990Group(int id) {
|
|
bool result = false;
|
|
switch (id) {
|
|
case 990:
|
|
case 991:
|
|
case 992:
|
|
case 993:
|
|
result = true;
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// OFFSET: 0x00CF0910
|
|
// FUNCTION: fn_21418
|
|
bool CGameMode::IsEffectId994Group(int id) {
|
|
bool result = false;
|
|
switch (id) {
|
|
case 994:
|
|
case 995:
|
|
case 996:
|
|
case 997:
|
|
result = true;
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// OFFSET: 0x00CF0950
|
|
// FUNCTION: fn_21419
|
|
bool CGameMode::ConfirmDraggedItemUse() {
|
|
if (g_session.unknown_16EC != this->drag.id) {
|
|
return false;
|
|
}
|
|
|
|
ITEM_INFO item = LookupClientItemByIdentity(g_session.m_inventoryItems, this->drag.id);
|
|
if (item.unknown_0000[1] > 0) {
|
|
if (g_replayAnimationScaling) {
|
|
this->unknown_05EC[0] = 0;
|
|
}
|
|
g_modeMgr.GetGameMode()->SendMsg(18, 0, 0, 0, 0);
|
|
reinterpret_cast<WindowDialogs*>(&g_windowMgr)->Confirm(LookupMessage(657), 0, true, false, 0, "Message", 280, 120, 0);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// OFFSET: 0x00CFE480
|
|
// FUNCTION: fn_21432
|
|
void CGameMode::sub_CFE480(int actorId) {
|
|
if (g_windowMgr.unknown_0508 != 2 && actorId == static_cast<int>(g_session.m_aid)) {
|
|
this->scene->player->unknown_0544->SendMsg(nullptr, 44, 0, 1, 0, 0, 0, 0);
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00CDBC30
|
|
// FUNCTION: fn_21312
|
|
void __stdcall sub_CDBC30(const vector3d* position, int actorId, float scale, int job) {
|
|
if (actorId == 0) {
|
|
return;
|
|
}
|
|
|
|
CSprArrowEffect* effect = static_cast<CSprArrowEffect*>(
|
|
g_effectMgr->Spawn(0, 0x964, position->x, position->y, position->z, actorId, -1, 0, 0)
|
|
);
|
|
if (effect != nullptr) {
|
|
effect->unknown_00F4 = scale;
|
|
effect->SetBulletSprite(job);
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00CE8F10
|
|
// FUNCTION: fn_21344
|
|
void __stdcall sub_CE8F10(const void* info, const unsigned char* data) {
|
|
if (Replay::Instance().state != 2) {
|
|
return;
|
|
}
|
|
|
|
if (Replay::Instance().header.options.recordRestricted == 0) {
|
|
return;
|
|
}
|
|
|
|
GameModeReplayPacket packet;
|
|
packet.header = 0x038A08AE;
|
|
packet.length = 0xFE;
|
|
std::memcpy(&packet.info, info, sizeof(packet.info));
|
|
std::memcpy(packet.data, data, sizeof(packet.data));
|
|
|
|
Replay& replay = Replay::Instance();
|
|
ReplayPacketRecorder recorder = {
|
|
g_packetLengths,
|
|
replay.baseFrame,
|
|
replay.started,
|
|
replay.frame,
|
|
replay.header.key0,
|
|
replay.header.key1,
|
|
replay.header.options.recordRestricted,
|
|
replay.file,
|
|
replay.fileOffset,
|
|
replay.records,
|
|
replay.cipherIndex,
|
|
replay.cipherBase,
|
|
replay.cipherKey,
|
|
};
|
|
recorder.Record(packet.length, &packet, 0x2A, 0);
|
|
}
|
|
|
|
// OFFSET: 0x00CDFAF0
|
|
// FUNCTION: fn_21325
|
|
void CGameMode::IgnorePacket() {
|
|
}
|
|
|
|
// OFFSET: 0x00CE8EC0
|
|
// FUNCTION: fn_21343
|
|
void CGameMode::RemoveUnknown01A4(int value) {
|
|
for (std::list<int>::iterator it = this->unknown_01A4.begin(); it != this->unknown_01A4.end(); ++it) {
|
|
if (*it == value) {
|
|
this->unknown_01A4.erase(it);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
#pragma pack(push, 1)
|
|
struct GameModeMessageRecord {
|
|
/* 0000 */ std::uint32_t header;
|
|
/* 0004 */ std::uint16_t length;
|
|
/* 0006 */ int message;
|
|
/* 000A */ int value;
|
|
/* 000E */ int first;
|
|
/* 0012 */ int second;
|
|
};
|
|
#pragma pack(pop)
|
|
|
|
static_assert(sizeof(GameModeMessageRecord) == 0x16);
|
|
|
|
// OFFSET: 0x00CE8FC0
|
|
// FUNCTION: fn_21345
|
|
bool CGameMode::RecordReplayMessage(int message, int value, int first, int second) {
|
|
if (Replay::Instance().state != 2 || message != 0x45 || value != 10000) {
|
|
return false;
|
|
}
|
|
|
|
GameModeMessageRecord record;
|
|
record.header = 0x038908AE;
|
|
record.length = sizeof(GameModeMessageRecord);
|
|
record.message = 0x45;
|
|
record.value = 10000;
|
|
record.first = first;
|
|
record.second = second;
|
|
|
|
Replay& replay = Replay::Instance();
|
|
ReplayPacketRecorder recorder = {
|
|
g_packetLengths,
|
|
replay.baseFrame,
|
|
replay.started,
|
|
replay.frame,
|
|
replay.header.key0,
|
|
replay.header.key1,
|
|
replay.header.options.recordRestricted,
|
|
replay.file,
|
|
replay.fileOffset,
|
|
replay.records,
|
|
replay.cipherIndex,
|
|
replay.cipherBase,
|
|
replay.cipherKey,
|
|
};
|
|
recorder.Record(record.length, &record, 0x2A, 0);
|
|
return true;
|
|
}
|
|
|
|
// OFFSET: 0x00CED260
|
|
// FUNCTION: fn_21364
|
|
void CGameMode::UpdateReplayActionSpeeds() {
|
|
CPlayer* player = this->scene->player;
|
|
player->SetActionSpeed(Replay::Instance().AnimationScale());
|
|
for (CRenderObject* actor : this->scene->actors) {
|
|
actor->SetActionSpeed(Replay::Instance().AnimationScale());
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00CF1060
|
|
// FUNCTION: fn_21425
|
|
ReplayTime CGameMode::StopReplayRecording() {
|
|
if (Replay::Instance().state != 2) {
|
|
return ReplayTime();
|
|
}
|
|
|
|
Replay::Instance().SetState(1);
|
|
Replay::Instance().UpdateDuration();
|
|
const ReplayTime duration = Replay::Instance().Duration();
|
|
Replay::Instance().CloseFile();
|
|
return duration;
|
|
}
|
|
|
|
#pragma pack(push, 1)
|
|
struct GameModeChunkHeader {
|
|
/* 0000 */ std::int16_t type;
|
|
/* 0002 */ std::uint32_t size;
|
|
};
|
|
#pragma pack(pop)
|
|
|
|
static_assert(sizeof(GameModeChunkHeader) == 6);
|
|
|
|
#pragma pack(push, 1)
|
|
struct GameModeStoredRecord00DA {
|
|
/* 0000 */ std::uint16_t type;
|
|
/* 0002 */ int value0002;
|
|
/* 0006 */ int value0006;
|
|
/* 000A */ std::uint16_t value000A;
|
|
/* 000C */ std::uint16_t value000C;
|
|
/* 000E */ unsigned char value000E;
|
|
/* 000F */ std::uint16_t value000F;
|
|
/* 0011 */ int value0011;
|
|
/* 0015 */ int value0015;
|
|
/* 0019 */ std::uint16_t value0019;
|
|
/* 001B */ std::uint16_t value001B;
|
|
/* 001D */ std::uint16_t value001D;
|
|
/* 001F */ std::uint16_t value001F;
|
|
/* 0021 */ std::uint16_t value0021;
|
|
/* 0023 */ std::uint16_t value0023;
|
|
/* 0025 */ char text[0x18];
|
|
/* 003D */ std::uint16_t value003D;
|
|
};
|
|
#pragma pack(pop)
|
|
|
|
static_assert(offsetof(GameModeStoredRecord00DA, text) == 0x25);
|
|
static_assert(offsetof(GameModeStoredRecord00DA, value003D) == 0x3D);
|
|
|
|
static_assert(sizeof(GameModeTextRecord) == 0x190);
|
|
static_assert(offsetof(GameModeTextRecord, buffer) == 0x1E);
|
|
|
|
// OFFSET: 0x00CFE4D0
|
|
// FUNCTION: fn_21433
|
|
void CGameMode::NotifyUnknown0604(int value) {
|
|
for (std::list<UIWindow*>::iterator it = this->unknown_0604.begin(); it != this->unknown_0604.end(); ++it) {
|
|
(*it)->SendMsg(nullptr, 60, value, 0, 0, 0);
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00CEBF30
|
|
// FUNCTION: fn_21354
|
|
unsigned CGameMode::sub_CEBF30(const std::vector<unsigned char>& data) {
|
|
if (data.empty()) {
|
|
return 0xFFFFFFFFu;
|
|
}
|
|
|
|
GameModeChunkHeader header = {};
|
|
unsigned offset = 6;
|
|
header = *reinterpret_cast<const GameModeChunkHeader*>(data.data());
|
|
if (header.type == 15000) {
|
|
while (offset < data.size()) {
|
|
header = {};
|
|
header = *reinterpret_cast<const GameModeChunkHeader*>(data.data() + offset);
|
|
offset += 6;
|
|
|
|
if (header.type == 0xCF) {
|
|
std::vector<unsigned char> record(0x13);
|
|
std::memcpy(record.data(), data.data() + offset, header.size);
|
|
offset += header.size;
|
|
this->sub_D2DB80(record.data());
|
|
} else if (header.type == 15001) {
|
|
break;
|
|
} else {
|
|
offset += header.size;
|
|
}
|
|
}
|
|
} else {
|
|
offset = 0xFFFFFFFFu;
|
|
}
|
|
|
|
return offset;
|
|
}
|
|
|
|
// OFFSET: 0x00CEC100
|
|
// FUNCTION: fn_21355
|
|
unsigned CGameMode::sub_CEC100(const std::vector<unsigned char>& data) {
|
|
if (data.empty()) {
|
|
return 0xFFFFFFFFu;
|
|
}
|
|
|
|
GameModeChunkHeader header = {};
|
|
unsigned offset = 6;
|
|
header = *reinterpret_cast<const GameModeChunkHeader*>(data.data());
|
|
if (header.type == 10000) {
|
|
std::vector<unsigned char> record;
|
|
while (offset < data.size()) {
|
|
header = {};
|
|
header = *reinterpret_cast<const GameModeChunkHeader*>(data.data() + offset);
|
|
offset += 6;
|
|
|
|
if (static_cast<int>(header.size) > 0) {
|
|
record.resize(header.size);
|
|
}
|
|
|
|
if (header.type == 10001) {
|
|
break;
|
|
}
|
|
|
|
switch (header.type) {
|
|
case 0xC9:
|
|
std::memcpy(record.data(), data.data() + offset, header.size);
|
|
offset += header.size;
|
|
this->sub_D3F130(record.data());
|
|
break;
|
|
case 0xCA:
|
|
std::memcpy(record.data(), data.data() + offset, header.size);
|
|
offset += header.size;
|
|
this->sub_D51A90(record.data());
|
|
break;
|
|
case 0xCB:
|
|
std::memcpy(record.data(), data.data() + offset, header.size);
|
|
offset += header.size;
|
|
this->sub_D3D2F0(record.data());
|
|
break;
|
|
case 0xCC:
|
|
std::memcpy(record.data(), data.data() + offset, header.size);
|
|
offset += header.size;
|
|
this->sub_D24430(record.data());
|
|
break;
|
|
case 0xD0:
|
|
std::memcpy(record.data(), data.data() + offset, header.size);
|
|
offset += header.size;
|
|
this->sub_D350A0(record.data());
|
|
break;
|
|
case 0xD2:
|
|
std::memcpy(record.data(), data.data() + offset, header.size);
|
|
offset += header.size;
|
|
this->sub_D37A10(record.data());
|
|
break;
|
|
case 0xD4:
|
|
std::memcpy(record.data(), data.data() + offset, header.size);
|
|
offset += header.size;
|
|
this->sub_D619E0(record.data());
|
|
break;
|
|
case 0xD5:
|
|
std::memcpy(record.data(), data.data() + offset, header.size);
|
|
offset += header.size;
|
|
this->sub_D61390(record.data());
|
|
break;
|
|
case 0xD6:
|
|
std::memcpy(record.data(), data.data() + offset, header.size);
|
|
offset += header.size;
|
|
this->sub_D616B0(record.data());
|
|
break;
|
|
case 0xD7:
|
|
std::memcpy(record.data(), data.data() + offset, header.size);
|
|
offset += header.size;
|
|
this->sub_D63D70(record.data());
|
|
break;
|
|
case 0xD8:
|
|
std::memcpy(record.data(), data.data() + offset, header.size);
|
|
offset += header.size;
|
|
this->sub_D63720(record.data());
|
|
break;
|
|
case 0xD9:
|
|
std::memcpy(record.data(), data.data() + offset, header.size);
|
|
offset += header.size;
|
|
this->sub_D63A40(record.data());
|
|
break;
|
|
case 0xDA: {
|
|
std::memcpy(record.data(), data.data() + offset, header.size);
|
|
offset += header.size;
|
|
const auto* stored = reinterpret_cast<const GameModeStoredRecord00DA*>(record.data());
|
|
this->sub_D7B170(
|
|
stored->value0002, stored->value0006, stored->value000A, stored->value000C, stored->value000E, stored->value000F,
|
|
stored->value0011, stored->value0015, stored->value0019, stored->value001B, stored->value001D, stored->value001F,
|
|
stored->value0021, stored->value0023, stored->text, stored->value003D
|
|
);
|
|
break;
|
|
}
|
|
case 0x191:
|
|
std::memcpy(record.data(), data.data() + offset, header.size);
|
|
offset += header.size;
|
|
this->sub_D65FC0(record.data());
|
|
break;
|
|
default:
|
|
offset += header.size;
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
offset = 0xFFFFFFFFu;
|
|
}
|
|
|
|
return offset;
|
|
}
|
|
|
|
// OFFSET: 0x00CCFD70
|
|
// FUNCTION: fn_21248
|
|
void CGameMode::UpdatePetFriendlyWindow(int previousFriendly) {
|
|
if (!g_serviceOptions.Get(0x128)) {
|
|
return;
|
|
}
|
|
|
|
if (g_session.GetPetFriendlyState(g_session.m_petFriendly) == 0 && g_session.m_petFriendly <= 100) {
|
|
if (this->unknown_0628.find(g_session.unknown_1010) == this->unknown_0628.end()) {
|
|
if (g_windowMgr.window_038C == nullptr) {
|
|
g_windowMgr.EnsureWindow(0x58);
|
|
}
|
|
|
|
this->UpdateUnknown0628(g_session.unknown_1010, true);
|
|
}
|
|
}
|
|
|
|
if (previousFriendly < g_session.m_petFriendly && g_session.m_petFriendly > 99) {
|
|
auto it = this->unknown_0628.find(g_session.unknown_1010);
|
|
if (it != this->unknown_0628.end()) {
|
|
this->unknown_0628.erase(it);
|
|
}
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00CECE30
|
|
// FUNCTION: fn_21362
|
|
bool CGameMode::SaveEmblemFile(const std::vector<unsigned char>& data) {
|
|
if (data.empty()) {
|
|
return false;
|
|
}
|
|
|
|
const int nameLength = *reinterpret_cast<const int*>(data.data());
|
|
std::string name;
|
|
name.assign(reinterpret_cast<const char*>(data.data() + 4), nameLength);
|
|
|
|
char path[260];
|
|
std::memset(path, 0, sizeof(path));
|
|
std::sprintf(path, "%s\\_tmpEmblem\\%s", g_applicationDirectory, name.c_str());
|
|
|
|
CFile file;
|
|
if (file.Open(path, 0, true, false)) {
|
|
file.Close();
|
|
} else {
|
|
file.Close();
|
|
std::FILE* output = std::fopen(path, "wb");
|
|
if (output != nullptr) {
|
|
std::fwrite(data.data() + 4 + nameLength, data.size() - nameLength - 4, 1, output);
|
|
std::fclose(output);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// OFFSET: 0x00CF0E30
|
|
|
|
// OFFSET: 0x00CF0BA0
|
|
// FUNCTION: fn_21423
|
|
void WriteMyLog(const char* file, int line, const char* format, ...) {
|
|
char message[0x801];
|
|
std::memset(message, 0, sizeof(message));
|
|
|
|
va_list arguments;
|
|
va_start(arguments, format);
|
|
_vsnprintf(message, 0x800, format, arguments);
|
|
va_end(arguments);
|
|
|
|
if (std::strrchr(file, '\\') != nullptr) {
|
|
file = std::strrchr(file, '\\');
|
|
}
|
|
|
|
std::string path = FormatString("mylog(%s).txt", "");
|
|
std::FILE* output = std::fopen(path.c_str(), "a");
|
|
if (output != nullptr) {
|
|
SYSTEMTIME time;
|
|
GetLocalTime(&time);
|
|
std::fprintf(
|
|
output, "%-30s(%04d) %02d-%02d-%02d %02d:%02d:%02d.%03d %s\n", file, line, time.wYear, time.wMonth, time.wDay, time.wHour,
|
|
time.wMinute, time.wSecond, time.wMilliseconds, message
|
|
);
|
|
std::fclose(output);
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00CF0090
|
|
// FUNCTION: fn_21411
|
|
std::string CGameMode::HuntTargetText(const RenewQuestOngoingInfo& quest, int index) {
|
|
std::string text;
|
|
if (std::strlen(quest.m_huntName[index]) == 0) {
|
|
text.assign(g_renewQuestMgr->GetMonsterConditionText(quest.m_huntUnknown01A0[index], quest.m_huntUnknown01AC[index], quest.m_huntUnknown01B2[index]));
|
|
} else {
|
|
text.assign(FormatOwnedString("%s", quest.m_huntName[index]));
|
|
}
|
|
|
|
if (quest.m_huntUnknown00E0[index] == quest.m_huntUnknown0180[index]) {
|
|
text.assign(FormatOwnedString("%s [ %s ]", text.c_str(), LookupMessage(0x7EE)));
|
|
} else {
|
|
text.assign(FormatOwnedString("%s [ %d / %d ]", text.c_str(), quest.m_huntUnknown00E0[index], quest.m_huntUnknown0180[index]));
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
#pragma pack(push, 1)
|
|
struct GameModeStoredSkillEffect {
|
|
/* 0000 */ GameModeChunkHeader header;
|
|
/* 0006 */ ActiveSkillEffect effect;
|
|
};
|
|
#pragma pack(pop)
|
|
|
|
static_assert(sizeof(GameModeStoredSkillEffect) == 0x22);
|
|
|
|
#pragma pack(push, 1)
|
|
struct GameModeStoredValue {
|
|
/* 0000 */ GameModeChunkHeader header;
|
|
/* 0006 */ int value;
|
|
};
|
|
#pragma pack(pop)
|
|
|
|
static_assert(sizeof(GameModeStoredValue) == 0xA);
|
|
|
|
// OFFSET: 0x00CE9050
|
|
// FUNCTION: fn_21346
|
|
std::vector<unsigned char> CGameMode::SaveActiveSkillEffects() {
|
|
std::vector<unsigned char> data;
|
|
|
|
{
|
|
std::vector<unsigned char> chunk(sizeof(GameModeChunkHeader));
|
|
auto* header = reinterpret_cast<GameModeChunkHeader*>(chunk.data());
|
|
header->type = 19000;
|
|
header->size = 0;
|
|
data.insert(data.end(), chunk.begin(), chunk.end());
|
|
}
|
|
|
|
for (ActiveSkillEffect effect : g_activeSkillEffects) {
|
|
if (effect.unknown_0004 != 0 && effect.unknown_0004 != 999999) {
|
|
effect.unknown_0004 -= timeGetTime();
|
|
}
|
|
|
|
std::vector<unsigned char> chunk(sizeof(GameModeStoredSkillEffect));
|
|
auto* record = reinterpret_cast<GameModeStoredSkillEffect*>(chunk.data());
|
|
record->header.type = 0x4A43;
|
|
record->header.size = sizeof(ActiveSkillEffect);
|
|
record->effect = effect;
|
|
data.insert(data.end(), chunk.begin(), chunk.end());
|
|
}
|
|
|
|
{
|
|
std::vector<unsigned char> chunk(sizeof(GameModeChunkHeader));
|
|
auto* header = reinterpret_cast<GameModeChunkHeader*>(chunk.data());
|
|
header->type = 19001;
|
|
header->size = 0;
|
|
data.insert(data.end(), chunk.begin(), chunk.end());
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
// OFFSET: 0x00CE9DB0
|
|
// FUNCTION: fn_21348
|
|
std::vector<unsigned char> CGameMode::SaveUnknown024C() {
|
|
std::vector<unsigned char> data;
|
|
|
|
{
|
|
std::vector<unsigned char> chunk(sizeof(GameModeChunkHeader));
|
|
auto* header = reinterpret_cast<GameModeChunkHeader*>(chunk.data());
|
|
header->type = 14000;
|
|
header->size = 0;
|
|
data.insert(data.end(), chunk.begin(), chunk.end());
|
|
}
|
|
|
|
{
|
|
std::vector<unsigned char> chunk(sizeof(GameModeStoredValue));
|
|
auto* record = reinterpret_cast<GameModeStoredValue*>(chunk.data());
|
|
record->header.type = 14011;
|
|
record->header.size = sizeof(int);
|
|
record->value = this->unknown_024C;
|
|
data.insert(data.end(), chunk.begin(), chunk.end());
|
|
}
|
|
|
|
{
|
|
std::vector<unsigned char> chunk(sizeof(GameModeChunkHeader));
|
|
auto* header = reinterpret_cast<GameModeChunkHeader*>(chunk.data());
|
|
header->type = 14001;
|
|
header->size = 0;
|
|
data.insert(data.end(), chunk.begin(), chunk.end());
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
// OFFSET: 0x00CF0E30
|
|
// FUNCTION: fn_21424
|
|
void CGameMode::SendNpcInputText(std::uint32_t npcId, const char* text, const char* replacement, int unused) {
|
|
if (npcId != 0 && this->scene->GetGameActorByAID(npcId) == nullptr) {
|
|
return;
|
|
}
|
|
|
|
char buffer[0x16A];
|
|
std::memset(buffer, 0, sizeof(buffer));
|
|
StringFormat(buffer, sizeof(buffer), static_cast<std::size_t>(-1), "%s", replacement != nullptr ? replacement : text);
|
|
if (g_navigationLinkParser->HasUnownedItemLink(buffer) == true) {
|
|
return;
|
|
}
|
|
|
|
const std::size_t length = std::strlen(buffer);
|
|
unsigned char* packet = static_cast<unsigned char*>(
|
|
_MallocaComputeSize(length + 8) != 0
|
|
? (_MallocaComputeSize(length + 8) <= _ALLOCA_S_THRESHOLD
|
|
? _MarkAllocaS(_alloca(_MallocaComputeSize(length + 8)), _ALLOCA_S_STACK_MARKER)
|
|
: _MarkAllocaS(std::malloc(_MallocaComputeSize(length + 8)), _ALLOCA_S_HEAP_MARKER))
|
|
: nullptr
|
|
);
|
|
if (packet == nullptr) {
|
|
return;
|
|
}
|
|
|
|
*reinterpret_cast<std::uint32_t*>(packet + 4) = npcId;
|
|
*reinterpret_cast<std::uint16_t*>(packet) = 0x1D5;
|
|
*reinterpret_cast<std::uint16_t*>(packet + 2) = static_cast<std::uint16_t>(length + 8);
|
|
memcpy_s(packet + 8, length, buffer, length);
|
|
GetRagConnection().Send(*reinterpret_cast<std::uint16_t*>(packet + 2), packet);
|
|
_freea(packet);
|
|
}
|
|
|
|
// GLOBAL: gl_25200
|
|
float g_cameraMinDistance = 230.0f;
|
|
|
|
// GLOBAL: gl_24576
|
|
float g_cameraBaseDistance = 300.0f;
|
|
|
|
// GLOBAL: gl_25201
|
|
float g_cameraPitch = -45.0f;
|
|
|
|
// GLOBAL: gl_25202
|
|
float g_indoorCameraPitch = -45.0f;
|
|
|
|
// GLOBAL: gl_25203
|
|
float g_indoorCameraDistance = 300.0f;
|
|
|
|
// GLOBAL: gl_25204
|
|
float g_outdoorCameraPitch = -45.0f;
|
|
|
|
// GLOBAL: gl_25205
|
|
float g_outdoorCameraDistance = 300.0f;
|
|
|
|
// OFFSET: 0x00CECB90
|
|
// FUNCTION: fn_21359
|
|
void CGameMode::InitializeCamera() {
|
|
this->camera->camera.target[0] = this->scene->player->render.position.x;
|
|
this->camera->camera.target[1] = this->scene->player->render.position.y;
|
|
this->camera->camera.target[2] = this->scene->player->render.position.z;
|
|
this->camera->camera.desiredTarget[0] = this->scene->player->render.position.x;
|
|
this->camera->camera.desiredTarget[1] = this->scene->player->render.position.y;
|
|
this->camera->camera.desiredTarget[2] = this->scene->player->render.position.z;
|
|
this->hasViewParameters = 0;
|
|
|
|
int found;
|
|
const std::vector<std::string>* parameters = g_session.GetMapViewParameters(this->mapName, &found);
|
|
if (found != 0) {
|
|
this->hasViewParameters = 1;
|
|
for (int index = 0; index < 9; ++index) {
|
|
this->viewParameters[index] = static_cast<std::int16_t>(std::atof((*parameters)[index].c_str()));
|
|
}
|
|
}
|
|
|
|
const bool indoor = g_session.IsUnknownName5248(this->mapName);
|
|
this->unknown_0254 = !indoor;
|
|
float pitchRange = 10.0f;
|
|
float maxDistance = g_cameraBaseDistance;
|
|
float pitch;
|
|
float distance;
|
|
if (!indoor) {
|
|
pitchRange = 20.0f;
|
|
maxDistance = g_serviceOptionJitterScale;
|
|
pitch = g_outdoorCameraPitch;
|
|
distance = g_outdoorCameraDistance;
|
|
} else {
|
|
this->unknown_0288 = 45.0f;
|
|
this->camera->camera.yaw = 45.0f;
|
|
this->camera->camera.desiredYaw = this->unknown_0288;
|
|
pitch = g_indoorCameraPitch;
|
|
distance = g_indoorCameraDistance;
|
|
}
|
|
|
|
g_cameraDistance = distance;
|
|
g_cameraPitch = pitch;
|
|
if (-45.0f - pitchRange > pitch) {
|
|
pitch = -45.0f - pitchRange;
|
|
g_cameraPitch = pitch;
|
|
}
|
|
if (pitch > pitchRange - 45.0f) {
|
|
pitch = pitchRange - 45.0f;
|
|
g_cameraPitch = pitch;
|
|
}
|
|
if (g_cameraMinDistance > distance) {
|
|
distance = g_cameraMinDistance;
|
|
g_cameraDistance = distance;
|
|
}
|
|
if (distance > maxDistance) {
|
|
g_cameraDistance = maxDistance;
|
|
}
|
|
|
|
if (this->hasViewParameters != 0) {
|
|
g_cameraDistance = static_cast<float>(this->viewParameters[2]);
|
|
this->camera->camera.yaw = static_cast<float>(this->viewParameters[5]);
|
|
this->camera->camera.desiredYaw = static_cast<float>(this->viewParameters[5]);
|
|
pitch = static_cast<float>(this->viewParameters[8]);
|
|
g_cameraPitch = pitch;
|
|
}
|
|
|
|
this->camera->camera.pitch = pitch;
|
|
this->camera->camera.desiredPitch = g_cameraPitch;
|
|
this->camera->camera.distance = g_cameraDistance;
|
|
this->camera->camera.desiredDistance = g_cameraDistance;
|
|
}
|
|
|
|
#include "Contents/Schedule/Schedule.h"
|
|
#include "UI/Text/UINameBalloonText.h"
|
|
#include "UI/Text/UITransBalloonText.h"
|
|
#include "Contents/Actors/Pc.h"
|
|
#include "ActorPickNode.h"
|
|
#include "Client/Registry.h"
|
|
#include "Contents/Schedule/CheckGDISchedule.h"
|
|
#include "Contents/Schedule/TimeScheduler.h"
|
|
#include "Render/DX9/RendererFrameDX9.h"
|
|
#include "Render/Textures/TextureCache.h"
|
|
#include "Contents/ClientItemLists.h"
|
|
#include "Contents/Jobs/JobInheritance.h"
|
|
#include "Network/Packets/PacketId.h"
|
|
#include "Security/ReassemblyPacketMgr.h"
|
|
#include "UI/Dialogs/UIWaitWnd.h"
|
|
#include <chrono>
|
|
#include <winsock2.h>
|
|
#include "UI/Window/UIWordDisplayWnd.h"
|
|
#include "Contents/Actors/ActorStateFlags.h"
|
|
|
|
class CPingLiveSchedule : public CSchedule {
|
|
public:
|
|
void Process(const std::uint64_t& now) override;
|
|
};
|
|
|
|
// OFFSET: 0x00CDEDF0
|
|
// FUNCTION: fn_21321
|
|
void CPingLiveSchedule::Process(const std::uint64_t& now) {
|
|
this->timestamp = now;
|
|
if (GetRagConnection().NativeSocket() == INVALID_SOCKET) {
|
|
this->active = false;
|
|
return;
|
|
}
|
|
|
|
const DWORD tick = timeGetTime();
|
|
if (g_session.m_lastReceiveTick + 60000 < tick) {
|
|
this->active = false;
|
|
GetRagConnection().Close();
|
|
g_windowMgr.EnsureWindow(332);
|
|
return;
|
|
}
|
|
|
|
if (g_session.m_lastSendTick + 10000 < tick) {
|
|
std::uint16_t packet = 0xB1C;
|
|
GetRagConnection().Send(sizeof(packet), &packet);
|
|
}
|
|
}
|
|
|
|
#include "Client/Application/ApplicationWindow.h"
|
|
#include "Client/Mode/CLoginMode.h"
|
|
#include "Client/ModeFadeOut.h"
|
|
#include "Render/DeviceContext/DCSurface.h"
|
|
#include "Render/RenderSystemBase.h"
|
|
#include "Resource/ResourceMgr.h"
|
|
#include "Security/NProtectGameGuardMgr.h"
|
|
#include "Utility/Cipher/XorBytes.h"
|
|
|
|
namespace {
|
|
|
|
template <std::size_t Length, std::uint64_t Key>
|
|
class GameModeEncryptedName {
|
|
public:
|
|
explicit GameModeEncryptedName(const std::uint8_t (&source)[Length]) : m_encrypted(true) {
|
|
for (std::uint64_t index = 0; index < Length; ++index) {
|
|
this->m_text[index] = source[index];
|
|
}
|
|
}
|
|
|
|
~GameModeEncryptedName() {
|
|
for (std::uint64_t index = 0; index < Length; ++index) {
|
|
this->m_text[index] = 0;
|
|
}
|
|
}
|
|
|
|
const char* Text() {
|
|
if (this->m_encrypted) {
|
|
utility::XorBytes(this->m_text, Length, Key);
|
|
this->m_encrypted = false;
|
|
}
|
|
|
|
return reinterpret_cast<const char*>(this->m_text);
|
|
}
|
|
|
|
private:
|
|
/* 0000 */ std::uint8_t m_text[Length];
|
|
bool m_encrypted;
|
|
};
|
|
|
|
}
|
|
|
|
// OFFSET: 0x00CDEF00
|
|
// FUNCTION: fn_21322
|
|
int CGameMode::Run() {
|
|
while (this->running) {
|
|
if (g_modalImmediate) {
|
|
break;
|
|
}
|
|
|
|
if (g_windowMgr.modalWindows.empty() || g_windowMgr.modalWindows.back() == nullptr) {
|
|
if (!g_windowMgr.persistentWindows.empty()) {
|
|
if (g_windowMgr.retainedPersistentWindow) {
|
|
for (UIWindow* window : g_windowMgr.persistentWindows) {
|
|
g_windowMgr.Schedule(window);
|
|
}
|
|
g_windowMgr.retainedPersistentWindow = false;
|
|
}
|
|
g_windowMgr.persistentWindows.clear();
|
|
}
|
|
|
|
if (this->pendingCursorType != -1) {
|
|
this->cursorType = this->pendingCursorType;
|
|
this->cursorFrame = 0;
|
|
this->pendingCursorType = -1;
|
|
this->Slot7(this->cursorType);
|
|
}
|
|
}
|
|
|
|
if (g_nProtectGameGuardMgr->HasError()) {
|
|
GetRagConnection().Close();
|
|
g_modeMgr.Quit();
|
|
std::string message = g_nProtectGameGuardMgr->ErrorMessage();
|
|
if (!message.empty()) {
|
|
const std::uint8_t source[] = {0x53, 0x11, 0xF9, 0xA6, 0x8D, 0x7E, 0xA6, 0xD9, 0x1D, 0x06,
|
|
0xEA, 0xA4, 0x9C, 0x5C, 0xB0, 0xCC, 0x4F, 0x25, 0x8B};
|
|
thread_local GameModeEncryptedName<sizeof(source), 0xADC51BF9C98B413DULL> name(source);
|
|
MessageBoxA(hWnd, message.c_str(), name.Text(), 0);
|
|
}
|
|
}
|
|
|
|
this->Update();
|
|
Sleep(1);
|
|
}
|
|
|
|
FadeOutMode(*g_renderer, *GetRenderSystemHolder()->system, ResourceMgr::Instance(), 0, false, 0.0f, 0.0f);
|
|
return 1;
|
|
}
|
|
|
|
#include "Client/Input/Mouse.h"
|
|
|
|
// OFFSET: 0x00CDFC40
|
|
// FUNCTION: fn_21327
|
|
void CGameMode::TargetActorByAid(int aid) {
|
|
if (this->unknown_0250 != 0) {
|
|
return;
|
|
}
|
|
|
|
const unsigned char selfTargetOption = g_serviceOptions.Get(0x69);
|
|
const unsigned char forceOption = g_serviceOptions.Get(0x6D);
|
|
const int shiftHeld = HIBYTE(GetAsyncKeyState(VK_SHIFT));
|
|
int force = shiftHeld;
|
|
const std::intptr_t mode = reinterpret_cast<std::intptr_t>(this->unknown_0408);
|
|
const bool skillMode = mode == 2 || mode == 4;
|
|
const bool allowed = aid != static_cast<int>(g_session.m_aid) || mode == 4;
|
|
|
|
if (skillMode == true) {
|
|
const bool support = IsSupportSkill(this->unknown_040C);
|
|
const bool optionalSelf = IsOptionalSelfTargetSkill(this->unknown_040C);
|
|
if (support == true) {
|
|
force = 1;
|
|
}
|
|
if ((selfTargetOption != 0 || shiftHeld != 0) && optionalSelf == true) {
|
|
force = 1;
|
|
}
|
|
|
|
CWorld* scene = this->scene;
|
|
if (scene->unknown_0048 == 0 && scene->unknown_0054 == 0) {
|
|
if (scene->unknown_004C != 0) {
|
|
CGameActor* actor = static_cast<CGameActor*>(scene->GetGameActorByAID(aid));
|
|
if (actor != nullptr && !g_session.IsLocalPlayerAid(actor->Slot50())) {
|
|
GuildInfo* guildInfo = reinterpret_cast<GuildInfo*>(reinterpret_cast<char*>(&g_guildId) - offsetof(GuildInfo, m_guildId));
|
|
if (!guildInfo->HasRelatedGuild(actor->Slot50())) {
|
|
force = 1;
|
|
}
|
|
}
|
|
}
|
|
} else if (!g_session.IsPartyMember(aid, true)) {
|
|
force = 1;
|
|
}
|
|
}
|
|
|
|
if (allowed && g_mouse.buttons[0] == 1 && force != 0 && !HIBYTE(GetAsyncKeyState(VK_MENU))) {
|
|
this->SendMsg(0x1A, 1, 0, 0, 0);
|
|
*reinterpret_cast<int*>(&this->unknown_00D8[0x20]) = 0;
|
|
if (g_session.GetSceneUnknown004C() == 0 && (HIBYTE(GetAsyncKeyState(VK_CONTROL)) || forceOption != 0)) {
|
|
this->RequestPlayerAction(aid, 0);
|
|
*reinterpret_cast<int*>(&this->unknown_04F4[0xBC]) = 1;
|
|
return;
|
|
}
|
|
this->RequestPlayerAction(aid, 1);
|
|
*reinterpret_cast<int*>(&this->unknown_04F4[0xBC]) = 0;
|
|
}
|
|
}
|
|
|
|
#include "Contents/Actors/Skill.h"
|
|
|
|
#pragma pack(push, 1)
|
|
struct SkillEntryPacket {
|
|
/* 0000 */ std::int16_t packetType;
|
|
/* 0002 */ std::uint32_t aid;
|
|
/* 0006 */ std::uint32_t creatorAid;
|
|
/* 000A */ std::int16_t x;
|
|
/* 000C */ std::int16_t y;
|
|
/* 000E */ unsigned char job;
|
|
/* 000F */ unsigned char isVisible;
|
|
};
|
|
#pragma pack(pop)
|
|
|
|
static_assert(sizeof(SkillEntryPacket) == 16);
|
|
|
|
// OFFSET: 0x00CEB4C0
|
|
// FUNCTION: fn_21351
|
|
std::vector<unsigned char> CGameMode::WriteReplaySkillState() {
|
|
std::vector<unsigned char> output;
|
|
{
|
|
const auto record = BuildReplayTaggedRecord(17000, nullptr, 0);
|
|
output.insert(output.end(), record.begin(), record.end());
|
|
}
|
|
|
|
for (CRenderObject* object : this->scene->unknown_0020) {
|
|
CSkill* skill = static_cast<CSkill*>(object);
|
|
SkillEntryPacket packet;
|
|
packet.packetType = 0x11F;
|
|
packet.aid = skill->skillAid;
|
|
packet.creatorAid = static_cast<std::uint32_t>(skill->unknown_0410);
|
|
packet.job = static_cast<unsigned char>(skill->GetEffectiveJob(-1));
|
|
packet.isVisible = 1;
|
|
|
|
const C3dAttr* terrain = this->scene->terrain;
|
|
const float column = static_cast<float>(std::floor(static_cast<float>(terrain->width / 2) + skill->render.position.x / static_cast<float>(terrain->cellSize)));
|
|
const float row = static_cast<float>(std::floor(static_cast<float>(terrain->height / 2) + skill->render.position.z / static_cast<float>(terrain->cellSize)));
|
|
packet.x = static_cast<std::int16_t>(static_cast<int>(column));
|
|
packet.y = static_cast<std::int16_t>(static_cast<int>(row));
|
|
|
|
const auto record = BuildReplayTaggedRecord(0xCD, &packet, sizeof(packet));
|
|
output.insert(output.end(), record.begin(), record.end());
|
|
}
|
|
|
|
{
|
|
const auto record = BuildReplayTaggedRecord(17001, nullptr, 0);
|
|
output.insert(output.end(), record.begin(), record.end());
|
|
}
|
|
return output;
|
|
}
|
|
|
|
// OFFSET: 0x00CEBBB0
|
|
// FUNCTION: fn_21353
|
|
unsigned CGameMode::sub_CEBBB0(const std::vector<unsigned char>& data) {
|
|
if (data.empty()) {
|
|
return 0xFFFFFFFFu;
|
|
}
|
|
|
|
GameModeChunkHeader header = {};
|
|
std::vector<unsigned char> record;
|
|
unsigned offset = 6;
|
|
std::uint32_t guildId = 0;
|
|
header = *reinterpret_cast<const GameModeChunkHeader*>(data.data());
|
|
if (header.type == 13000) {
|
|
while (offset < data.size()) {
|
|
header = {};
|
|
header = *reinterpret_cast<const GameModeChunkHeader*>(data.data() + offset);
|
|
offset += 6;
|
|
|
|
if (static_cast<int>(header.size) > 0) {
|
|
record.resize(header.size);
|
|
}
|
|
|
|
switch (header.type) {
|
|
case 13001:
|
|
goto finished;
|
|
case 13002:
|
|
std::memcpy(record.data(), data.data() + offset, header.size);
|
|
offset += header.size;
|
|
this->SaveEmblemFile(record);
|
|
break;
|
|
case 13003:
|
|
std::memcpy(record.data(), data.data() + offset, header.size);
|
|
offset += header.size;
|
|
this->nameCard.Load(reinterpret_cast<const std::vector<char>&>(record));
|
|
break;
|
|
case 13004:
|
|
std::memcpy(&guildId, data.data() + offset, header.size);
|
|
offset += header.size;
|
|
break;
|
|
case 13005: {
|
|
int emblemVersion = 0;
|
|
std::memcpy(&emblemVersion, data.data() + offset, header.size);
|
|
offset += header.size;
|
|
this->scene->player->Slot49(guildId, emblemVersion);
|
|
g_guildId = guildId;
|
|
break;
|
|
}
|
|
default:
|
|
offset += header.size;
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
offset = 0xFFFFFFFFu;
|
|
}
|
|
|
|
finished:
|
|
return offset;
|
|
}
|
|
|
|
#include "Contents/Actors/Item.h"
|
|
#include <cstdlib>
|
|
|
|
// OFFSET: 0x00CE93E0
|
|
// FUNCTION: fn_21347
|
|
std::vector<unsigned char> CGameMode::SaveNameCardState() {
|
|
std::vector<unsigned char> data;
|
|
|
|
{
|
|
std::vector<unsigned char> chunk(sizeof(GameModeChunkHeader));
|
|
auto* header = reinterpret_cast<GameModeChunkHeader*>(chunk.data());
|
|
header->type = 13000;
|
|
header->size = 0;
|
|
data.insert(data.end(), chunk.begin(), chunk.end());
|
|
}
|
|
|
|
std::vector<char> buffer;
|
|
std::vector<std::string> names;
|
|
if (static_cast<int>(this->nameCard.Save(buffer)) > 0) {
|
|
std::vector<unsigned char> chunk(buffer.size() + sizeof(GameModeChunkHeader));
|
|
auto* header = reinterpret_cast<GameModeChunkHeader*>(chunk.data());
|
|
header->type = 13003;
|
|
header->size = buffer.size();
|
|
if (buffer.size() != 0) {
|
|
std::memcpy(chunk.data() + sizeof(GameModeChunkHeader), buffer.data(), buffer.size());
|
|
}
|
|
data.insert(data.end(), chunk.begin(), chunk.end());
|
|
}
|
|
|
|
{
|
|
const int emblemVersion = g_guildMgr->GetEmblemVersion(this->scene->player->Slot50());
|
|
if (this->AppendGuildEmblem(buffer, names, this->scene->player->Slot50(), emblemVersion)) {
|
|
std::vector<unsigned char> chunk(buffer.size() + sizeof(GameModeChunkHeader));
|
|
auto* header = reinterpret_cast<GameModeChunkHeader*>(chunk.data());
|
|
header->type = 13002;
|
|
header->size = buffer.size();
|
|
if (buffer.size() != 0) {
|
|
std::memcpy(chunk.data() + sizeof(GameModeChunkHeader), buffer.data(), buffer.size());
|
|
}
|
|
data.insert(data.end(), chunk.begin(), chunk.end());
|
|
}
|
|
}
|
|
|
|
{
|
|
const int guildId = this->scene->player->Slot50();
|
|
std::vector<unsigned char> chunk(sizeof(GameModeStoredValue));
|
|
auto* record = reinterpret_cast<GameModeStoredValue*>(chunk.data());
|
|
record->header.type = 13004;
|
|
record->header.size = sizeof(int);
|
|
record->value = guildId;
|
|
data.insert(data.end(), chunk.begin(), chunk.end());
|
|
}
|
|
|
|
{
|
|
const int emblemVersion = g_guildMgr->GetEmblemVersion(this->scene->player->Slot50());
|
|
std::vector<unsigned char> chunk(sizeof(GameModeStoredValue));
|
|
auto* record = reinterpret_cast<GameModeStoredValue*>(chunk.data());
|
|
record->header.type = 13005;
|
|
record->header.size = sizeof(int);
|
|
record->value = emblemVersion;
|
|
data.insert(data.end(), chunk.begin(), chunk.end());
|
|
}
|
|
|
|
for (CRenderObject* object : this->scene->actors) {
|
|
CGameActor* actor = static_cast<CGameActor*>(object);
|
|
const int emblemVersion = g_guildMgr->GetEmblemVersion(actor->Slot50());
|
|
if (this->AppendGuildEmblem(buffer, names, actor->Slot50(), emblemVersion)) {
|
|
std::vector<unsigned char> chunk(buffer.size() + sizeof(GameModeChunkHeader));
|
|
auto* header = reinterpret_cast<GameModeChunkHeader*>(chunk.data());
|
|
header->type = 13002;
|
|
header->size = buffer.size();
|
|
if (buffer.size() != 0) {
|
|
std::memcpy(chunk.data() + sizeof(GameModeChunkHeader), buffer.data(), buffer.size());
|
|
}
|
|
data.insert(data.end(), chunk.begin(), chunk.end());
|
|
}
|
|
}
|
|
|
|
{
|
|
std::vector<unsigned char> chunk(sizeof(GameModeChunkHeader));
|
|
auto* header = reinterpret_cast<GameModeChunkHeader*>(chunk.data());
|
|
header->type = 13001;
|
|
header->size = 0;
|
|
data.insert(data.end(), chunk.begin(), chunk.end());
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
#include "UI/Chat/UIChatRoomTitle.h"
|
|
#include "UI/Shop/UIMerchantShopTitle.h"
|
|
#include "UI/Text/UIStaticText.h"
|
|
|
|
#pragma pack(push, 1)
|
|
struct ChatRoomEntryPacket {
|
|
/* 0000 */ std::uint16_t packetType;
|
|
/* 0002 */ std::uint16_t packetLength;
|
|
/* 0004 */ std::uint32_t aid;
|
|
/* 0008 */ std::uint32_t roomId;
|
|
/* 000C */ std::uint16_t maxCount;
|
|
/* 000E */ std::uint16_t curCount;
|
|
/* 0010 */ unsigned char type;
|
|
};
|
|
|
|
struct ShopEntryPacket {
|
|
/* 0000 */ std::uint16_t packetType;
|
|
/* 0002 */ std::uint32_t aid;
|
|
/* 0006 */ char name[0x50];
|
|
};
|
|
|
|
struct ProgressPacket {
|
|
/* 0000 */ std::uint16_t packetType;
|
|
/* 0002 */ std::uint32_t color;
|
|
/* 0006 */ std::uint32_t seconds;
|
|
};
|
|
|
|
struct GameModeStoredRecord0191 {
|
|
/* 0000 */ std::uint16_t value0000;
|
|
/* 0002 */ std::uint32_t aid;
|
|
/* 0006 */ std::uint16_t value0006;
|
|
/* 0008 */ int value0008;
|
|
/* 000C */ int value000C;
|
|
/* 0010 */ int count;
|
|
/* 0014 */ int value0014;
|
|
/* 0018 */ int value0018;
|
|
};
|
|
#pragma pack(pop)
|
|
|
|
static_assert(sizeof(ChatRoomEntryPacket) == 0x11);
|
|
static_assert(sizeof(ShopEntryPacket) == 0x56);
|
|
static_assert(sizeof(ProgressPacket) == 0xA);
|
|
static_assert(sizeof(GameModeStoredRecord0191) == 0x1C);
|
|
static_assert(sizeof(GameModeStoredRecord00DA) == 0x3F);
|
|
|
|
// OFFSET: 0x00CEA510
|
|
// FUNCTION: fn_21350
|
|
std::vector<unsigned char> CGameMode::SaveActorStates() {
|
|
std::vector<unsigned char> data;
|
|
|
|
{
|
|
std::vector<unsigned char> chunk(sizeof(GameModeChunkHeader));
|
|
auto* header = reinterpret_cast<GameModeChunkHeader*>(chunk.data());
|
|
header->type = 10000;
|
|
header->size = 0;
|
|
data.insert(data.end(), chunk.begin(), chunk.end());
|
|
}
|
|
|
|
std::vector<unsigned char> scratch;
|
|
for (std::list<CRenderObject*>::iterator it = this->scene->actors.begin(); it != this->scene->actors.end(); ++it) {
|
|
CGameActor* actor = static_cast<CGameActor*>(*it);
|
|
CPc* pc = static_cast<CPc*>(actor);
|
|
|
|
if (actor->unknown_03E0Low == 0) {
|
|
if (actor->render.unknown_0070 == 1) {
|
|
std::vector<char> entry = this->BuildActorEntryPacket(actor, 0x9FD);
|
|
std::vector<unsigned char> chunk(entry.size() + sizeof(GameModeChunkHeader), 0);
|
|
auto* header = reinterpret_cast<GameModeChunkHeader*>(chunk.data());
|
|
header->type = 0xD6;
|
|
header->size = entry.size();
|
|
if (entry.size() != 0) {
|
|
std::memcpy(chunk.data() + sizeof(GameModeChunkHeader), entry.data(), entry.size());
|
|
}
|
|
data.insert(data.end(), chunk.begin(), chunk.end());
|
|
} else {
|
|
std::vector<char> entry = this->BuildActorEntryPacket(actor, 0x9FF);
|
|
std::vector<unsigned char> chunk(entry.size() + sizeof(GameModeChunkHeader), 0);
|
|
auto* header = reinterpret_cast<GameModeChunkHeader*>(chunk.data());
|
|
header->type = 0xD9;
|
|
header->size = entry.size();
|
|
if (entry.size() != 0) {
|
|
std::memcpy(chunk.data() + sizeof(GameModeChunkHeader), entry.data(), entry.size());
|
|
}
|
|
data.insert(data.end(), chunk.begin(), chunk.end());
|
|
}
|
|
}
|
|
|
|
UIChatRoomTitle* room = reinterpret_cast<UIChatRoomTitle*>(actor->unknown_0264[1]);
|
|
if (room != nullptr) {
|
|
scratch.resize(sizeof(ChatRoomEntryPacket), 0);
|
|
auto* packet = reinterpret_cast<ChatRoomEntryPacket*>(scratch.data());
|
|
packet->type = 0xD7;
|
|
packet->packetLength = static_cast<std::uint16_t>(room->title.size() + sizeof(ChatRoomEntryPacket));
|
|
packet->aid = actor->render.accountId;
|
|
packet->roomId = room->roomId;
|
|
packet->maxCount = static_cast<std::uint16_t>(room->memberLimit);
|
|
packet->curCount = static_cast<std::uint16_t>(room->memberCount);
|
|
packet->type = static_cast<unsigned char>(room->roomType);
|
|
scratch.insert(scratch.end(), room->title.begin(), room->title.end());
|
|
|
|
std::vector<unsigned char> chunk(scratch.size() + sizeof(GameModeChunkHeader));
|
|
auto* header = reinterpret_cast<GameModeChunkHeader*>(chunk.data());
|
|
header->type = 0xC9;
|
|
header->size = scratch.size();
|
|
if (scratch.size() != 0) {
|
|
std::memcpy(chunk.data() + sizeof(GameModeChunkHeader), scratch.data(), scratch.size());
|
|
}
|
|
data.insert(data.end(), chunk.begin(), chunk.end());
|
|
}
|
|
|
|
if (actor->unknown_03E0Low == 1) {
|
|
std::vector<unsigned char> record;
|
|
record.resize(sizeof(GameModeStoredRecord00DA), 0);
|
|
auto* stored = reinterpret_cast<GameModeStoredRecord00DA*>(record.data());
|
|
stored->value0002 = actor->render.accountId;
|
|
stored->value0006 = actor->GetEffectiveJob(-1);
|
|
stored->value000E = static_cast<unsigned char>(actor->unknown_0260);
|
|
stored->value000A = static_cast<std::uint16_t>(actor->unknown_0158[5]);
|
|
stored->value000C = static_cast<std::uint16_t>(*reinterpret_cast<const int*>(actor->unknown_0170));
|
|
stored->value000F = static_cast<std::uint16_t>(pc->unknown_0440);
|
|
const std::int64_t value = actor->Slot35();
|
|
stored->value0011 = static_cast<int>(value);
|
|
stored->value0015 = static_cast<int>(value >> 32);
|
|
stored->value0019 = static_cast<std::uint16_t>(pc->unknown_0450);
|
|
stored->value001B = static_cast<std::uint16_t>(pc->unknown_0454);
|
|
stored->value001D = static_cast<std::uint16_t>(pc->unknown_0458);
|
|
stored->value001F = static_cast<std::uint16_t>(pc->unknown_0444);
|
|
stored->value0021 = static_cast<std::uint16_t>(actor->render.unknown_0048);
|
|
stored->value0023 = static_cast<std::uint16_t>(pc->unknown_049C);
|
|
stored->value003D = static_cast<std::uint16_t>(actor->Slot46());
|
|
{
|
|
std::string name = this->nameCard.Name(actor->render.accountId);
|
|
std::memcpy(stored->text, name.c_str(), sizeof(stored->text));
|
|
}
|
|
|
|
std::vector<unsigned char> chunk(record.size() + sizeof(GameModeChunkHeader));
|
|
auto* header = reinterpret_cast<GameModeChunkHeader*>(chunk.data());
|
|
header->type = 0xDA;
|
|
header->size = record.size();
|
|
if (record.size() != 0) {
|
|
std::memcpy(chunk.data() + sizeof(GameModeChunkHeader), record.data(), record.size());
|
|
}
|
|
data.insert(data.end(), chunk.begin(), chunk.end());
|
|
}
|
|
|
|
UIMerchantShopTitle* shop = reinterpret_cast<UIMerchantShopTitle*>(actor->unknown_0264[2]);
|
|
if (shop != nullptr) {
|
|
scratch.resize(sizeof(ShopEntryPacket), 0);
|
|
auto* packet = reinterpret_cast<ShopEntryPacket*>(scratch.data());
|
|
packet->packetType = 0x131;
|
|
packet->aid = actor->render.accountId;
|
|
std::memcpy(packet->name, shop->label->tooltip.c_str(), sizeof(packet->name));
|
|
|
|
std::vector<unsigned char> chunk(scratch.size() + sizeof(GameModeChunkHeader));
|
|
auto* header = reinterpret_cast<GameModeChunkHeader*>(chunk.data());
|
|
header->type = 0xCA;
|
|
header->size = scratch.size();
|
|
if (scratch.size() != 0) {
|
|
std::memcpy(chunk.data() + sizeof(GameModeChunkHeader), scratch.data(), scratch.size());
|
|
}
|
|
data.insert(data.end(), chunk.begin(), chunk.end());
|
|
}
|
|
|
|
if (actor->unknown_0264[3] != 0) {
|
|
scratch.resize(sizeof(ProgressPacket), 0);
|
|
auto* packet = reinterpret_cast<ProgressPacket*>(scratch.data());
|
|
packet->color = 0;
|
|
packet->packetType = 0x2F0;
|
|
packet->seconds = (actor->unknown_0280 - actor->unknown_0284) / 1000;
|
|
|
|
std::vector<unsigned char> chunk(scratch.size() + sizeof(GameModeChunkHeader));
|
|
auto* header = reinterpret_cast<GameModeChunkHeader*>(chunk.data());
|
|
header->type = 0xCB;
|
|
header->size = scratch.size();
|
|
if (scratch.size() != 0) {
|
|
std::memcpy(chunk.data() + sizeof(GameModeChunkHeader), scratch.data(), scratch.size());
|
|
}
|
|
data.insert(data.end(), chunk.begin(), chunk.end());
|
|
}
|
|
|
|
UIMerchantShopTitle* buyingShop = reinterpret_cast<UIMerchantShopTitle*>(actor->unknown_0264[4]);
|
|
if (buyingShop != nullptr) {
|
|
scratch.resize(sizeof(ShopEntryPacket), 0);
|
|
auto* packet = reinterpret_cast<ShopEntryPacket*>(scratch.data());
|
|
packet->packetType = 0x814;
|
|
packet->aid = actor->render.accountId;
|
|
std::memcpy(packet->name, buyingShop->label->tooltip.c_str(), sizeof(packet->name));
|
|
|
|
std::vector<unsigned char> chunk(scratch.size() + sizeof(GameModeChunkHeader), 0);
|
|
auto* header = reinterpret_cast<GameModeChunkHeader*>(chunk.data());
|
|
header->type = 0xCC;
|
|
header->size = scratch.size();
|
|
if (scratch.size() != 0) {
|
|
std::memcpy(chunk.data() + sizeof(GameModeChunkHeader), scratch.data(), scratch.size());
|
|
}
|
|
data.insert(data.end(), chunk.begin(), chunk.end());
|
|
}
|
|
|
|
const int count = actor->Slot56();
|
|
if (count > 0) {
|
|
GameModeStoredRecord0191 record;
|
|
record.value000C = 9999;
|
|
record.value0000 = 0;
|
|
record.count = count;
|
|
record.value0014 = 0;
|
|
record.value0008 = 9999;
|
|
record.aid = actor->render.accountId;
|
|
record.value0006 = 0x47D;
|
|
record.value0018 = 0;
|
|
|
|
std::vector<unsigned char> chunk(sizeof(GameModeChunkHeader) + sizeof(record), 0);
|
|
auto* header = reinterpret_cast<GameModeChunkHeader*>(chunk.data());
|
|
header->type = 0x191;
|
|
header->size = sizeof(record);
|
|
*reinterpret_cast<GameModeStoredRecord0191*>(chunk.data() + sizeof(GameModeChunkHeader)) = record;
|
|
data.insert(data.end(), chunk.begin(), chunk.end());
|
|
}
|
|
}
|
|
|
|
{
|
|
std::vector<unsigned char> chunk(sizeof(GameModeChunkHeader), 0);
|
|
auto* header = reinterpret_cast<GameModeChunkHeader*>(chunk.data());
|
|
header->type = 10001;
|
|
header->size = 0;
|
|
data.insert(data.end(), chunk.begin(), chunk.end());
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
#pragma pack(push, 1)
|
|
struct ItemEntryPacket {
|
|
/* 0000 */ std::int16_t packetType;
|
|
/* 0002 */ std::uint32_t aid;
|
|
/* 0006 */ std::uint32_t itemId;
|
|
/* 000A */ unsigned char identified;
|
|
/* 000B */ std::int16_t x;
|
|
/* 000D */ std::int16_t y;
|
|
/* 000F */ std::int16_t count;
|
|
/* 0011 */ unsigned char subX;
|
|
/* 0012 */ unsigned char subY;
|
|
};
|
|
|
|
struct GameModeStoredItemEntry {
|
|
/* 0000 */ GameModeChunkHeader header;
|
|
/* 0006 */ ItemEntryPacket packet;
|
|
};
|
|
#pragma pack(pop)
|
|
|
|
static_assert(sizeof(ItemEntryPacket) == 0x13);
|
|
static_assert(sizeof(GameModeStoredItemEntry) == 0x19);
|
|
|
|
#include "Contents/Items/ItemNaming.h"
|
|
#include "Contents/NavigationManager.h"
|
|
#include "UI/Navigation/UINavigationV4Wnd.h"
|
|
#include "UI/Window/UINavigationWnd.h"
|
|
#include "Contents/Effects/EffectActor.h"
|
|
|
|
#pragma pack(push, 1)
|
|
struct GameModeUiMessage {
|
|
/* 0000 */ std::uint16_t unknown_0000;
|
|
/* 0002 */ std::uint16_t type;
|
|
/* 0004 */ std::uint16_t length;
|
|
/* 0006 */ int values[6];
|
|
/* 001E */ char text[1];
|
|
};
|
|
|
|
struct GameModeUiWhisperMessage {
|
|
/* 0000 */ std::uint16_t unknown_0000;
|
|
/* 0002 */ std::uint16_t type;
|
|
/* 0004 */ std::uint16_t length;
|
|
/* 0006 */ char target[0x19];
|
|
/* 001F */ char text[1];
|
|
};
|
|
|
|
struct GameModeUiKindTextMessage {
|
|
/* 0000 */ std::uint16_t unknown_0000;
|
|
/* 0002 */ std::uint16_t type;
|
|
/* 0004 */ std::uint16_t length;
|
|
/* 0006 */ int kind;
|
|
/* 000A */ int unknown_000A;
|
|
/* 000E */ char text[1];
|
|
};
|
|
|
|
struct GameModeUiNavigationMessage {
|
|
/* 0000 */ std::uint16_t unknown_0000;
|
|
/* 0002 */ std::uint16_t type;
|
|
/* 0004 */ std::uint16_t length;
|
|
/* 0006 */ char name[0x1E];
|
|
/* 0024 */ int kind;
|
|
/* 0028 */ unsigned char mode;
|
|
/* 0029 */ unsigned char flag;
|
|
/* 002A */ int x;
|
|
/* 002E */ int y;
|
|
/* 0032 */ int id;
|
|
};
|
|
|
|
struct GameModeUiDestinationMessage {
|
|
/* 0000 */ std::uint16_t unknown_0000;
|
|
/* 0002 */ std::uint16_t type;
|
|
/* 0004 */ std::uint16_t length;
|
|
/* 0006 */ char mapName[0x1E];
|
|
/* 0024 */ int x;
|
|
/* 0028 */ int y;
|
|
};
|
|
|
|
struct GameModeUiDragMessage {
|
|
/* 0000 */ std::uint16_t unknown_0000;
|
|
/* 0002 */ std::uint16_t type;
|
|
/* 0004 */ std::uint16_t length;
|
|
/* 0006 */ int windowId;
|
|
/* 000A */ int x;
|
|
/* 000E */ int y;
|
|
/* 0012 */ int source;
|
|
/* 0016 */ std::uint32_t id;
|
|
/* 001A */ std::uint32_t unknown_001A;
|
|
/* 001E */ std::uint32_t unknown_001E;
|
|
/* 0022 */ int quantity;
|
|
/* 0026 */ int slot;
|
|
/* 002A */ std::uint32_t itemType;
|
|
/* 002E */ std::uint32_t refine;
|
|
/* 0032 */ unsigned char identified;
|
|
/* 0033 */ char resource[100];
|
|
/* 0097 */ char name[100];
|
|
/* 00FB */ char skillName[100];
|
|
/* 015F */ int skillLevel;
|
|
/* 0163 */ unsigned char cards[16];
|
|
/* 0173 */ unsigned char skill;
|
|
/* 0174 */ int optionCount;
|
|
/* 0178 */ unsigned char options[25];
|
|
};
|
|
#pragma pack(pop)
|
|
|
|
static_assert(offsetof(GameModeUiMessage, text) == 0x1E);
|
|
static_assert(offsetof(GameModeUiWhisperMessage, text) == 0x1F);
|
|
static_assert(offsetof(GameModeUiKindTextMessage, text) == 0x0E);
|
|
static_assert(offsetof(GameModeUiNavigationMessage, id) == 0x32);
|
|
static_assert(offsetof(GameModeUiDestinationMessage, y) == 0x28);
|
|
static_assert(offsetof(GameModeUiDragMessage, options) == 0x178);
|
|
|
|
// OFFSET: 0x00CCF680
|
|
// FUNCTION: fn_21244
|
|
void CGameMode::ProcessUiMessage(unsigned char* message) {
|
|
GameModeUiMessage* values = reinterpret_cast<GameModeUiMessage*>(message);
|
|
|
|
switch (values->type) {
|
|
case 900: {
|
|
if (values->values[1] == 0xB8) {
|
|
if (values->values[0] == 0x29) {
|
|
values->values[1] = 0xB9;
|
|
} else if (values->values[0] == 0xAE) {
|
|
break;
|
|
}
|
|
}
|
|
UIWindow* window = g_windowMgr.LookupWindow(values->values[0]);
|
|
if (window != nullptr) {
|
|
window->SendMsg(nullptr, 6, values->values[1], values->values[2], values->values[3], values->values[4]);
|
|
}
|
|
break;
|
|
}
|
|
case 901:
|
|
this->ReceiveUiDragMessage(message);
|
|
break;
|
|
case 902: {
|
|
UIWindow* window = g_windowMgr.LookupWindow(values->values[0]);
|
|
if (window != nullptr) {
|
|
window->RestoreEditTexts(reinterpret_cast<const unsigned char*>(&values->values[1]));
|
|
}
|
|
break;
|
|
}
|
|
case 903:
|
|
*reinterpret_cast<int*>(&this->unknown_0100[0x10]) = values->values[0];
|
|
break;
|
|
case 904: {
|
|
char buffer[200];
|
|
std::memset(buffer, 0, sizeof(buffer));
|
|
std::memcpy(buffer, values->text, values->values[0]);
|
|
this->unknown_03C8 = buffer;
|
|
std::memset(buffer, 0, sizeof(buffer));
|
|
std::memcpy(buffer, values->text + values->values[0], values->values[1]);
|
|
this->unknown_03E0 = buffer;
|
|
this->unknown_03F8 = values->values[2];
|
|
this->unknown_03FC = values->values[3];
|
|
this->unknown_0400 = values->values[4];
|
|
this->unknown_0404 = values->values[5];
|
|
break;
|
|
}
|
|
case 905:
|
|
this->SendMsg(values->values[0], values->values[1], values->values[2], values->values[3], 0);
|
|
this->SendMsg(0x47, 0, 0, 0, 0);
|
|
break;
|
|
case 906: {
|
|
const GameModeUiWhisperMessage* whisper = reinterpret_cast<const GameModeUiWhisperMessage*>(message);
|
|
*reinterpret_cast<std::string*>(this->unknown_01F8 + 0x34) = whisper->target;
|
|
*reinterpret_cast<std::string*>(this->unknown_01F8 + 0x1C) = whisper->text;
|
|
break;
|
|
}
|
|
case 907: {
|
|
const GameModeUiKindTextMessage* text = reinterpret_cast<const GameModeUiKindTextMessage*>(message);
|
|
if (text->kind == 0x29) {
|
|
g_session.unknown_550C = text->text;
|
|
} else if (text->kind == 0xAE) {
|
|
g_session.unknown_550C = text->text;
|
|
}
|
|
break;
|
|
}
|
|
case 908:
|
|
if (values->values[0] == 0xCB && g_navigationWindow != nullptr) {
|
|
g_navigationWindow->SendMsg(nullptr, values->values[1], values->values[2], reinterpret_cast<std::intptr_t>(&values->values[3]), 0, 0);
|
|
}
|
|
break;
|
|
case 909:
|
|
g_windowMgr.EnsureWindow(values->values[0]);
|
|
break;
|
|
case 910: {
|
|
const GameModeUiNavigationMessage* navigation = reinterpret_cast<const GameModeUiNavigationMessage*>(message);
|
|
g_navigationManager.sub_B99030(
|
|
std::string(navigation->name), navigation->kind, navigation->mode, navigation->flag != 0, navigation->x, navigation->y, navigation->id
|
|
);
|
|
break;
|
|
}
|
|
case 911: {
|
|
std::vector<char> states(values->length - 6, 0);
|
|
std::memcpy(&states[0], values->values, states.size());
|
|
g_windowMgr.CloseWindow(0x1A);
|
|
g_navigationManager.LoadStates(states);
|
|
if (g_navigationWindow != nullptr) {
|
|
static_cast<UINavigationV4Wnd*>(g_navigationWindow)->FillRouteGroups();
|
|
}
|
|
break;
|
|
}
|
|
case 912: {
|
|
const GameModeUiDestinationMessage* destination = reinterpret_cast<const GameModeUiDestinationMessage*>(message);
|
|
g_navigationManager.SetDestinationMap(std::string(destination->mapName), destination->x, destination->y);
|
|
break;
|
|
}
|
|
case 913: {
|
|
if (values->values[1] == 0xB8) {
|
|
if (values->values[0] == 0x29) {
|
|
values->values[1] = 0xB9;
|
|
} else if (values->values[0] == 0xAE) {
|
|
break;
|
|
}
|
|
}
|
|
UIWindow* window = g_windowMgr.LookupWindow(values->values[0]);
|
|
if (window != nullptr) {
|
|
window->SendMsg(nullptr, values->values[5], values->values[1], values->values[2], values->values[3], values->values[4]);
|
|
}
|
|
break;
|
|
}
|
|
case 914:
|
|
g_windowMgr.CloseWindowExcept251(values->values[0]);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00CE8400
|
|
// FUNCTION: fn_21341
|
|
void CGameMode::ReceiveUiDragMessage(const unsigned char* message) {
|
|
const GameModeUiDragMessage* packet = reinterpret_cast<const GameModeUiDragMessage*>(message);
|
|
|
|
ModeDragState drag;
|
|
drag.source = packet->source;
|
|
drag.id = packet->id;
|
|
drag.unknown_0310 = packet->unknown_001A;
|
|
drag.unknown_0314 = packet->unknown_001E;
|
|
drag.quantity = packet->quantity;
|
|
drag.slot = packet->slot;
|
|
drag.type = packet->itemType;
|
|
drag.refine = packet->refine;
|
|
drag.identified = packet->identified;
|
|
drag.resource = packet->resource;
|
|
drag.name = packet->name;
|
|
drag.skillName = packet->skillName;
|
|
drag.skillLevel = packet->skillLevel;
|
|
std::memcpy(drag.cards, packet->cards, sizeof(drag.cards));
|
|
drag.skill = packet->skill;
|
|
drag.optionCount = packet->optionCount;
|
|
if (drag.optionCount > 5) {
|
|
drag.optionCount = 0;
|
|
}
|
|
for (int index = 0; index < drag.optionCount; ++index) {
|
|
std::memcpy(&drag.options[index * 5], &packet->options[index * 5], 5);
|
|
}
|
|
|
|
UIWindow* window = g_windowMgr.LookupWindow(packet->windowId);
|
|
this->drag = drag;
|
|
|
|
if (this->drag.quantity == 1) {
|
|
const int kind = packet->windowId;
|
|
if (kind == 0x17 || kind == 0x2C) {
|
|
if (packet->itemType <= 3 || packet->itemType == 7) {
|
|
this->unknown_05EC[0] = this->IsAllowedPair(kind, packet->source);
|
|
}
|
|
} else if (kind == 0x16) {
|
|
if (packet->itemType <= 3 || packet->itemType == 7) {
|
|
this->unknown_05EC[0] = this->IsAllowedPair(0x16, packet->source);
|
|
}
|
|
}
|
|
} else {
|
|
this->unknown_05EC[0] = this->IsAllowedPair(packet->windowId, packet->source);
|
|
}
|
|
|
|
if (window != nullptr) {
|
|
window->Slot10(packet->x, packet->y, reinterpret_cast<std::intptr_t>(&drag));
|
|
}
|
|
|
|
const int kind = packet->windowId;
|
|
if (kind == 0x24 || kind == 0x9F) {
|
|
this->unknown_05EC[0] = 0;
|
|
} else if (this->unknown_05EC[0] == 1 && g_windowMgr.window_01EC != nullptr) {
|
|
if (drag.type == 6) {
|
|
const ItemCardName card = FindItemCardName(std::atoi(drag.name.c_str()));
|
|
g_windowMgr.window_01EC->SendMsg(nullptr, 0x1D, 0, reinterpret_cast<std::intptr_t>(card.name), 0, 0);
|
|
} else {
|
|
const ITEM_DESC description = FindItemDescription(std::atoi(drag.name.c_str()));
|
|
g_windowMgr.window_01EC->SendMsg(nullptr, 0x1D, 0, reinterpret_cast<std::intptr_t>(description.identifiedName), 0, 0);
|
|
}
|
|
}
|
|
|
|
this->SendMsg(0x12, 0, 0, 0, 0);
|
|
}
|
|
|
|
// OFFSET: 0x00CDBEB0
|
|
|
|
// OFFSET: 0x00CEA0C0
|
|
// FUNCTION: fn_21349
|
|
std::vector<unsigned char> CGameMode::SaveGroundItems() {
|
|
std::vector<unsigned char> data;
|
|
|
|
{
|
|
std::vector<unsigned char> chunk(sizeof(GameModeChunkHeader));
|
|
auto* header = reinterpret_cast<GameModeChunkHeader*>(chunk.data());
|
|
header->type = 15000;
|
|
header->size = 0;
|
|
data.insert(data.end(), chunk.begin(), chunk.end());
|
|
}
|
|
|
|
for (CRenderObject* object : this->scene->unknown_0018) {
|
|
CItem* item = static_cast<CItem*>(object);
|
|
ItemEntryPacket packet;
|
|
packet.packetType = 0x9D;
|
|
packet.aid = item->itemAid;
|
|
packet.itemId = item->itemId;
|
|
packet.identified = item->identified;
|
|
|
|
int column;
|
|
int row;
|
|
int subColumn;
|
|
int subRow;
|
|
this->scene->terrain->Grid().WorldSubcell(item->render.position.x, item->render.position.z, column, row, subColumn, subRow);
|
|
packet.x = static_cast<std::int16_t>(column);
|
|
packet.y = static_cast<std::int16_t>(row);
|
|
packet.subX = static_cast<unsigned char>(subColumn);
|
|
|
|
const int length = static_cast<int>(item->name.size());
|
|
std::size_t digits = 0;
|
|
for (int index = length - 4; index >= 0; --index) {
|
|
if (item->name[index] == ' ') {
|
|
break;
|
|
}
|
|
++digits;
|
|
}
|
|
char text[6] = {};
|
|
std::memcpy(text, item->name.c_str() + (length - 3) - digits, digits);
|
|
packet.count = static_cast<std::int16_t>(std::atoi(text));
|
|
|
|
std::vector<unsigned char> chunk(sizeof(GameModeStoredItemEntry));
|
|
auto* record = reinterpret_cast<GameModeStoredItemEntry*>(chunk.data());
|
|
record->header.type = 0xCF;
|
|
record->header.size = sizeof(ItemEntryPacket);
|
|
packet.subY = static_cast<unsigned char>(subRow);
|
|
record->packet = packet;
|
|
data.insert(data.end(), chunk.begin(), chunk.end());
|
|
}
|
|
|
|
{
|
|
std::vector<unsigned char> chunk(sizeof(GameModeChunkHeader));
|
|
auto* header = reinterpret_cast<GameModeChunkHeader*>(chunk.data());
|
|
header->type = 15001;
|
|
header->size = 0;
|
|
data.insert(data.end(), chunk.begin(), chunk.end());
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
// OFFSET: 0x00CEFFC0
|
|
// FUNCTION: fn_21409
|
|
UIBroadcastBalloon* CGameMode::EnsureBroadcastBalloon() {
|
|
if (!this->broadcastBalloon) {
|
|
this->broadcastBalloon = new UIBroadcastBalloon(*reinterpret_cast<UIWindowContext*>(nullptr), *reinterpret_cast<UIButtonContext*>(nullptr));
|
|
this->broadcastBalloon->SetSize(g_renderer->viewport.width, 50);
|
|
this->broadcastBalloon->Move(0, 51);
|
|
g_windowMgr.AddRenderedFront(this->broadcastBalloon);
|
|
}
|
|
return this->broadcastBalloon;
|
|
}
|
|
|
|
// OFFSET: 0x00CDBB10
|
|
// FUNCTION: fn_21311
|
|
void CGameMode::EnsureNameBalloon(UINameBalloonText*& balloon) {
|
|
if (balloon) {
|
|
return;
|
|
}
|
|
|
|
g_serviceOptions.Get(0x5C);
|
|
balloon = new UINameBalloonText(*reinterpret_cast<UIWindowContext*>(nullptr), *reinterpret_cast<BalloonTextContext*>(nullptr));
|
|
balloon->SetSize(8, 8);
|
|
g_windowMgr.AddRenderedFront(balloon);
|
|
}
|
|
|
|
// OFFSET: 0x00CDD240
|
|
// FUNCTION: fn_21315
|
|
void __stdcall OpenWordDisplay(CGameActor* actor) {
|
|
if (actor->unknown_018C || IsAdminAccount(actor->render.accountId)) {
|
|
return;
|
|
}
|
|
|
|
if (!IsAdminAccount(g_session.m_aid)) {
|
|
if (StateFlag02(actor->Slot13()) || StateFlag01(actor->Slot13()) || StateFlag06(actor->Slot13())) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
UIWordDisplayWnd* window = new UIWordDisplayWnd(*reinterpret_cast<UIWindowContext*>(nullptr), *reinterpret_cast<UIFrameContext*>(nullptr));
|
|
window->SendMsg(nullptr, 34, actor->render.accountId, 0, 0, 0);
|
|
g_windowMgr.AddRendered(window);
|
|
actor->unknown_018C = reinterpret_cast<int>(window);
|
|
}
|
|
|
|
// OFFSET: 0x00CFF070
|
|
// FUNCTION: fn_21435
|
|
void CGameMode::ShowNoticeBalloon(const std::vector<std::string>* lines) {
|
|
if (!lines || lines->empty()) {
|
|
return;
|
|
}
|
|
|
|
UIBroadcastBalloon* balloon = this->noticeBalloon;
|
|
if (!balloon) {
|
|
this->noticeBalloon = new UIBroadcastBalloon(*reinterpret_cast<UIWindowContext*>(nullptr), *reinterpret_cast<UIButtonContext*>(nullptr));
|
|
this->noticeBalloon->SetSize(g_renderer->viewport.width, 50);
|
|
this->noticeBalloon->Move(0, 130 * g_renderer->viewport.height / 480);
|
|
g_windowMgr.AddRenderedFront(this->noticeBalloon);
|
|
balloon = this->noticeBalloon;
|
|
if (!balloon) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
BroadcastBalloonMessage message{{}, {}, std::chrono::seconds(20), 12, 0x40000000, 0, 0};
|
|
message.start = std::chrono::system_clock::now();
|
|
for (std::vector<std::string>::const_iterator it = lines->begin(); it != lines->end(); ++it) {
|
|
message.lines.push_back(BroadcastBalloonLine{*it, 0xFFFF, 0});
|
|
}
|
|
balloon->AddMessage(2, message);
|
|
}
|
|
|
|
#pragma pack(push, 1)
|
|
struct ZoneEnterPacket {
|
|
/* 0000 */ std::uint16_t packetType;
|
|
/* 0002 */ std::uint32_t aid;
|
|
/* 0006 */ std::uint32_t gid;
|
|
/* 000A */ int authCode;
|
|
/* 000E */ unsigned char unknown_000E[4];
|
|
/* 0012 */ std::uint32_t clientTime;
|
|
/* 0016 */ unsigned char sex;
|
|
};
|
|
#pragma pack(pop)
|
|
|
|
static_assert(sizeof(ZoneEnterPacket) == 0x17);
|
|
static_assert(offsetof(ZoneEnterPacket, clientTime) == 0x12);
|
|
static_assert(offsetof(ZoneEnterPacket, sex) == 0x16);
|
|
|
|
// OFFSET: 0x00D06CB0
|
|
// FUNCTION: fn_21579
|
|
void CGameMode::ChangeZoneServer(std::string mapName, int x, int y, int ip, int port, std::string host) {
|
|
g_session.m_startTimeTicks = std::chrono::system_clock::now().time_since_epoch().count();
|
|
g_session.m_loginTimeTicks = std::chrono::system_clock::now().time_since_epoch().count();
|
|
g_session.SetOption(20, 1, 0);
|
|
this->nameCard.Clear();
|
|
g_session.ClearEntryList5BD4();
|
|
g_session.ClearShortcutSlots();
|
|
g_session.ClearSecondaryShortcutSlots();
|
|
g_session.unknown_6184 = 0;
|
|
g_session.ResetInventoryItems();
|
|
reinterpret_cast<ClientItemLists&>(g_session).ClearPartyMembers();
|
|
|
|
std::string name = mapName;
|
|
name.resize(name.size() - 4);
|
|
g_session.SetNavigationPlayerMap(name.c_str());
|
|
g_session.m_playerX = x;
|
|
g_session.m_playerY = y;
|
|
|
|
in_addr address;
|
|
address.s_addr = static_cast<ULONG>(ip);
|
|
StringFormat(g_zoneServerIp, sizeof(g_zoneServerIp), static_cast<std::size_t>(-1), inet_ntoa(address));
|
|
g_zoneServerPort = port;
|
|
StringFormat(g_zoneServerHost, sizeof(g_zoneServerHost), static_cast<std::size_t>(-1), "%s", host.c_str());
|
|
GetRagConnection().Close();
|
|
g_activeSkillEffects.clear();
|
|
|
|
*reinterpret_cast<int*>(this->unknown_01F8 + 0x4C) = 1;
|
|
*reinterpret_cast<std::uint32_t*>(this->unknown_01F8 + 0x50) = timeGetTime();
|
|
this->scene->player->SendMsg(nullptr, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
|
|
if (g_screenShakeDuration > 0) {
|
|
g_screenShakeDuration = g_screenShakeMode == 2 ? 10001 : g_screenShakeDuration;
|
|
}
|
|
|
|
if (g_replayAnimationScaling == 0) {
|
|
this->unknown_0018 = GetRagConnection().Connect(*reinterpret_cast<const ConnectionEndpoint*>(g_zoneServerIp));
|
|
if (!this->unknown_0018) {
|
|
GetRagConnection().Close();
|
|
if (reinterpret_cast<WindowDialogs*>(&g_windowMgr)->Confirm(LookupMessage(1), 1, true, true, 0, "Message", 280, 120, 0) != 269) {
|
|
this->SendMsg(141, 0, 0, 0, 0);
|
|
}
|
|
return;
|
|
}
|
|
|
|
g_nProtectGameGuardMgr->IncrementCounter();
|
|
g_packetReassembler->Notify(1);
|
|
GetRagConnection().SendDeadline() = timeGetTime() + 1000;
|
|
|
|
ZoneEnterPacket packet;
|
|
packet.packetType = ID_CZ_ENTER2;
|
|
packet.clientTime = timeGetTime();
|
|
packet.aid = g_session.m_aid;
|
|
packet.gid = g_session.m_gid;
|
|
packet.authCode = reinterpret_cast<const int*>(g_session.unknown_0E9C)[2];
|
|
packet.sex = static_cast<unsigned char>(g_session.SyncUnknown0E98());
|
|
GetRagConnection().Send(reinterpret_cast<const PacketLengths&>(GetRagConnection()).FixedLength(packet.packetType), &packet);
|
|
g_session.SetOption(17, 1, 0);
|
|
GetRagConnection().SetBlock(1);
|
|
}
|
|
|
|
static_cast<UIWaitWnd*>(g_windowMgr.EnsureWindow(6))->SetMessage(LookupMessage(122), 16, 1);
|
|
g_windowMgr.unknown_0474 = 185;
|
|
}
|
|
|
|
// OFFSET: 0x00CE1FA0
|
|
// FUNCTION: fn_21333
|
|
void CGameMode::UpdateBalloons() {
|
|
if (this->nameBalloon) {
|
|
if (*reinterpret_cast<int*>(&this->unknown_02B8[0x0C])) {
|
|
g_windowMgr.Schedule(this->nameBalloon);
|
|
this->nameBalloon = nullptr;
|
|
} else {
|
|
*reinterpret_cast<int*>(&this->unknown_02B8[0x0C]) = 1;
|
|
if (this->balloonActorId == g_session.m_aid) {
|
|
this->PlaceWindowAtActor(this->nameBalloon, reinterpret_cast<CGameActor*>(this->scene->player));
|
|
} else if (CRenderObject* actor = this->scene->GetGameActorByAID(this->balloonActorId)) {
|
|
this->PlaceWindowAtActor(this->nameBalloon, reinterpret_cast<CGameActor*>(actor));
|
|
} else if (CItem* item = this->scene->GetItemByAID(this->balloonActorId)) {
|
|
this->PlaceWindowAtActor(this->nameBalloon, reinterpret_cast<CGameActor*>(item));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this->itemNameBalloon) {
|
|
if (*reinterpret_cast<int*>(&this->unknown_02B8[0x10])) {
|
|
g_windowMgr.Schedule(this->itemNameBalloon);
|
|
this->itemNameBalloon = nullptr;
|
|
} else {
|
|
*reinterpret_cast<int*>(&this->unknown_02B8[0x10]) = 1;
|
|
if (this->balloonActorId == g_session.m_aid) {
|
|
this->PlaceWindowAtActor(this->itemNameBalloon, reinterpret_cast<CGameActor*>(this->scene->player));
|
|
} else if (CRenderObject* actor = this->scene->GetGameActorByAID(this->balloonActorId)) {
|
|
this->PlaceWindowAtActor(this->itemNameBalloon, reinterpret_cast<CGameActor*>(actor));
|
|
} else if (CItem* item = this->scene->GetItemByAID(this->balloonActorId)) {
|
|
this->PlaceWindowAtActor(this->itemNameBalloon, reinterpret_cast<CGameActor*>(item));
|
|
}
|
|
}
|
|
}
|
|
|
|
UIWindow*& skillBalloon = *reinterpret_cast<UIWindow**>(&this->unknown_02B8[0x00]);
|
|
UIWindow*& hintBalloon = *reinterpret_cast<UIWindow**>(&this->unknown_02B8[0x04]);
|
|
int& shownSkill = *reinterpret_cast<int*>(&this->unknown_045C[0x04]);
|
|
if (this->unknown_0408 == nullptr) {
|
|
if (skillBalloon) {
|
|
g_windowMgr.Schedule(skillBalloon);
|
|
skillBalloon = nullptr;
|
|
}
|
|
if (hintBalloon) {
|
|
g_windowMgr.Schedule(hintBalloon);
|
|
hintBalloon = nullptr;
|
|
}
|
|
} else {
|
|
bool created = false;
|
|
if (!skillBalloon) {
|
|
skillBalloon = new UITransBalloonText(*reinterpret_cast<UIWindowContext*>(nullptr), *reinterpret_cast<BalloonTextContext*>(nullptr));
|
|
skillBalloon->SetSize(8, 8);
|
|
g_windowMgr.AddRendered(skillBalloon);
|
|
created = true;
|
|
}
|
|
|
|
if (shownSkill != this->unknown_040C || created == true) {
|
|
std::string text;
|
|
shownSkill = this->unknown_040C;
|
|
switch (shownSkill) {
|
|
case 10000: {
|
|
const std::uint8_t source[] = {0xBC, 0x82, 0x2D, 0x77, 0xD2, 0xDD, 0xC6, 0x1F, 0xB2, 0x8C, 0x33, 0x70, 0xD3, 0xCA, 0xD1, 0x3F};
|
|
thread_local GameModeEncryptedName<sizeof(source), 0x3FA3AFA7035DE3FFULL> name(source);
|
|
text.assign(name.Text());
|
|
break;
|
|
}
|
|
case 20000: {
|
|
const std::uint8_t source[] = {0x09, 0xEB, 0x66, 0x1C, 0x26, 0xAE, 0x07, 0x96, 0x38, 0xF5, 0x71, 0x04, 0x75, 0x86, 0x42, 0xDB};
|
|
thread_local GameModeEncryptedName<sizeof(source), 0xDB27CB557D038759ULL> name(source);
|
|
text = name.Text();
|
|
break;
|
|
}
|
|
case 20001: {
|
|
const std::uint8_t source[] = {0xCF, 0xD8, 0x9B, 0x0E, 0xCE, 0x19, 0xF9, 0x30, 0xEF, 0xC4, 0xBB};
|
|
thread_local GameModeEncryptedName<sizeof(source), 0x51BB39B763BBBD8DULL> name(source);
|
|
text = name.Text();
|
|
break;
|
|
}
|
|
case 40000: {
|
|
const std::uint8_t source[] = {0xAC, 0x4C, 0x27, 0x79, 0xB0, 0xA3, 0x86, 0xA7, 0xA2, 0x42, 0x39, 0x7E, 0xB1, 0xB4, 0x91, 0x87};
|
|
thread_local GameModeEncryptedName<sizeof(source), 0x87E3D1C50D572DEFULL> name(source);
|
|
text = name.Text();
|
|
break;
|
|
}
|
|
default:
|
|
if (g_session.IsState291To303(shownSkill)) {
|
|
const std::uint8_t source[] = {0x3E, 0x4A, 0xC2, 0xE6, 0x2F};
|
|
thread_local GameModeEncryptedName<sizeof(source), 0xB7AFBD2FD9FD7501ULL> name(source);
|
|
text = name.Text();
|
|
} else {
|
|
text = CSkillInfo::DisplayName(*g_luaScript, shownSkill);
|
|
}
|
|
break;
|
|
}
|
|
|
|
UITransBalloonText* balloon = static_cast<UITransBalloonText*>(skillBalloon);
|
|
balloon->SetText(text.c_str(), 35);
|
|
balloon->Move((g_renderer->viewport.width - 640) / 2 - balloon->geometry.width / 2 + 320, 46 * g_renderer->viewport.height / 480);
|
|
balloon->m_textColor = 0x32FF32;
|
|
balloon->m_outlineColor = 0;
|
|
}
|
|
|
|
if (!hintBalloon) {
|
|
UITransBalloonText* balloon = new UITransBalloonText(*reinterpret_cast<UIWindowContext*>(nullptr), *reinterpret_cast<BalloonTextContext*>(nullptr));
|
|
hintBalloon = balloon;
|
|
balloon->SetSize(8, 8);
|
|
g_windowMgr.AddRendered(hintBalloon);
|
|
static_cast<UITransBalloonText*>(hintBalloon)->SetText(LookupMessage(234), 35);
|
|
hintBalloon->Move((g_renderer->viewport.width - 640) / 2 - hintBalloon->geometry.width / 2 + 320, 400 * g_renderer->viewport.height / 480);
|
|
static_cast<UITransBalloonText*>(hintBalloon)->m_textColor = 0x32FF32;
|
|
static_cast<UITransBalloonText*>(hintBalloon)->m_outlineColor = 0;
|
|
}
|
|
}
|
|
|
|
if (this->itemWindow) {
|
|
CPlayer* player = this->scene->player;
|
|
const int x = player->render.screenX - 30;
|
|
const int y = player->render.screenY;
|
|
const int offset = static_cast<int>(static_cast<float>(12 * g_renderer->viewport.height / 480) * player->render.unknown_005C);
|
|
if (IsScreenShakeActive()) {
|
|
this->itemWindow->Move(x, y - offset);
|
|
} else {
|
|
this->itemWindow->Move(x, offset + y);
|
|
}
|
|
}
|
|
|
|
if (this->unknown_05FC && timeGetTime() > this->unknown_0600 + 10000) {
|
|
g_windowMgr.Schedule(this->unknown_05FC);
|
|
this->unknown_05FC = nullptr;
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00CDD7A0
|
|
// FUNCTION: fn_21319
|
|
void CGameMode::End() {
|
|
CSchedule* schedule = reinterpret_cast<CTimeScheduler*>(g_timeScheduler)->FindSchedule(g_session.m_pingLiveSchedule);
|
|
if (schedule) {
|
|
schedule->active = false;
|
|
}
|
|
reinterpret_cast<CTimeScheduler*>(g_timeScheduler)->sub_BA95F0(4);
|
|
this->StopReplayRecording();
|
|
g_soundMgr->EndSamples();
|
|
|
|
if (this->scene) {
|
|
this->scene->OnExitFrame();
|
|
delete this->scene;
|
|
}
|
|
|
|
if (this->camera) {
|
|
void** vtable = static_cast<void**>(this->camera->vtable);
|
|
reinterpret_cast<void(__thiscall*)(CView*)>(vtable[2])(this->camera);
|
|
reinterpret_cast<void(__thiscall*)(CView*, int)>(static_cast<void**>(this->camera->vtable)[0])(this->camera, 1);
|
|
}
|
|
|
|
g_actorPickNode.Clear();
|
|
ResourceMgr::Instance().ClearUnused("rsm");
|
|
ResourceMgr::Instance().ClearUnused("rsw");
|
|
ResourceMgr::Instance().ClearUnused("gat");
|
|
ResourceMgr::Instance().ClearExpired();
|
|
g_texMgr.ClearUnused();
|
|
RendererFrameDX9 frame{
|
|
*reinterpret_cast<DeviceOwnerDX9*>(nullptr), *reinterpret_cast<RendererDX9Operations*>(nullptr), g_renderer->commands,
|
|
g_renderer->primitives, g_renderer->lightmapped, g_renderer->vertices, g_renderer->queues, *reinterpret_cast<EffectRetirement*>(nullptr)
|
|
};
|
|
frame.Clear();
|
|
g_renderer->atlas.Clear();
|
|
g_windowMgr.SaveShortcutItems();
|
|
|
|
char subKey[512];
|
|
std::strcpy(subKey, g_subKey);
|
|
std::strcat(subKey, "\\NameBaloon");
|
|
std::strcat(subKey, "\\");
|
|
std::strcat(subKey, g_session.m_serverName.c_str());
|
|
HKEY key;
|
|
DWORD disposition = 0;
|
|
if (RegCreateKeyExA(HKEY_LOCAL_MACHINE, subKey, 0, nullptr, 0, KEY_ALL_ACCESS, nullptr, &key, &disposition) == ERROR_SUCCESS) {
|
|
DWORD value = g_serviceOptions.Get(92) != 0;
|
|
RegSetValueExA(key, "POS", 0, REG_DWORD, reinterpret_cast<const BYTE*>(&value), sizeof(value));
|
|
RegCloseKey(key);
|
|
}
|
|
|
|
if (this->unknown_0254) {
|
|
g_outdoorCameraPitch = g_cameraPitch;
|
|
g_outdoorCameraDistance = g_cameraDistance;
|
|
} else {
|
|
g_indoorCameraPitch = g_cameraPitch;
|
|
g_indoorCameraDistance = g_cameraDistance;
|
|
}
|
|
|
|
if (g_whisperRecord != 0) {
|
|
sub_CCFF10();
|
|
}
|
|
g_effectMgr->Clear();
|
|
g_session.SaveMiniPartyInfo();
|
|
g_session.SetUnknown8134(0);
|
|
}
|
|
|
|
#include "Contents/MapSkyMgr.h"
|
|
|
|
// OFFSET: 0x00CE8DE0
|
|
// FUNCTION: fn_21342
|
|
void CGameMode::ReloadScene() {
|
|
this->scene->Clear();
|
|
this->scene->CreatePlayer();
|
|
this->scene->LoadMapEffects();
|
|
g_weatherEffect.ResetEffect();
|
|
this->mousePointer = new CMousePointer();
|
|
this->scene->objects.push_back(this->mousePointer);
|
|
this->camera->camera.target[0] = this->scene->player->render.position.x;
|
|
this->camera->camera.target[1] = this->scene->player->render.position.y;
|
|
this->camera->camera.target[2] = this->scene->player->render.position.z;
|
|
}
|
|
|
|
// OFFSET: 0x00CDBEB0
|
|
// FUNCTION: fn_21314
|
|
void CGameMode::PlayItemUseEffect(int itemId, std::uint32_t aid) {
|
|
ITEM_INFO item = LookupClientItem(g_session.m_inventoryItems, itemId, 0);
|
|
|
|
CRenderObject* actor;
|
|
if (aid == g_session.m_aid) {
|
|
CPlayer* player = this->scene->player;
|
|
actor = player;
|
|
if (actor == nullptr) {
|
|
return;
|
|
}
|
|
|
|
if (itemId == 0x3113) {
|
|
const int job = player->GetEffectiveJob(-1);
|
|
char text[0x100];
|
|
strcpy_s(text, sizeof(text), LookupMessage(job >= 4054 && job <= 4112 ? 0x704 : 0x703));
|
|
g_windowMgr.SendNotice(1, reinterpret_cast<std::intptr_t>(text), 0xFFFF00, 8, 0, 0);
|
|
}
|
|
} else {
|
|
actor = this->scene->GetGameActorByAID(aid);
|
|
if (actor == nullptr) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
int effectId = -1;
|
|
int secondEffectId = -1;
|
|
switch (itemId) {
|
|
case 0x1F5:
|
|
case 0x1FB:
|
|
case 0x221:
|
|
case 0x239:
|
|
case 0x242:
|
|
case 0x256:
|
|
case 0x2D2F:
|
|
case 0x2D30:
|
|
case 0x2D32:
|
|
case 0x3909:
|
|
effectId = 0xCC;
|
|
break;
|
|
case 0x1F6:
|
|
case 0x243:
|
|
case 0x257:
|
|
case 0x2D31:
|
|
case 0x311E:
|
|
effectId = 0xCD;
|
|
break;
|
|
case 0x1F7:
|
|
case 0x1FC:
|
|
case 0x222:
|
|
case 0x2CEC:
|
|
case 0x2D2E:
|
|
case 0x2D36:
|
|
effectId = 0xCE;
|
|
break;
|
|
case 0x1F8:
|
|
case 0x1FD:
|
|
case 0x223:
|
|
case 0x22B:
|
|
case 0x22C:
|
|
case 0x22D:
|
|
case 0x2CED:
|
|
case 0x2CEF:
|
|
case 0x2D1C:
|
|
case 0x2D25:
|
|
case 0x2D26:
|
|
case 0x2D2D:
|
|
case 0x2D35:
|
|
effectId = 0xCF;
|
|
break;
|
|
case 0x1F9:
|
|
case 0x1FE:
|
|
case 0x2CEE:
|
|
case 0x2CF0:
|
|
case 0x2D1D:
|
|
case 0x2D34:
|
|
effectId = 0xD0;
|
|
break;
|
|
case 0x1FA:
|
|
case 0x1FF:
|
|
case 0x2D33:
|
|
effectId = 0xD1;
|
|
break;
|
|
case 0x200:
|
|
case 0x201:
|
|
case 0x203:
|
|
case 0x204:
|
|
case 0x213:
|
|
case 0x214:
|
|
case 0x216:
|
|
case 0x217:
|
|
case 0x224:
|
|
case 0x225:
|
|
case 0x226:
|
|
case 0x246:
|
|
case 0x2AA:
|
|
effectId = 0xD2;
|
|
break;
|
|
case 0x202:
|
|
case 0x215:
|
|
case 0x238:
|
|
case 0x25F:
|
|
case 0x2A8:
|
|
case 0x2AB:
|
|
case 0x302D:
|
|
case 0x3037:
|
|
case 0x3039:
|
|
case 0x3041:
|
|
effectId = 0xD3;
|
|
break;
|
|
case 0x205:
|
|
case 0x206:
|
|
case 0x207:
|
|
case 0x208:
|
|
case 0x209:
|
|
case 0x20E:
|
|
case 0x210:
|
|
case 0x211:
|
|
case 0x212:
|
|
case 0x218:
|
|
case 0x219:
|
|
case 0x21A:
|
|
case 0x21B:
|
|
case 0x21C:
|
|
case 0x21D:
|
|
case 0x21E:
|
|
case 0x21F:
|
|
case 0x220:
|
|
case 0x227:
|
|
case 0x228:
|
|
case 0x229:
|
|
case 0x232:
|
|
case 0x233:
|
|
case 0x234:
|
|
case 0x235:
|
|
case 0x236:
|
|
case 0x237:
|
|
case 0x23A:
|
|
case 0x23B:
|
|
case 0x23C:
|
|
case 0x23F:
|
|
case 0x240:
|
|
case 0x241:
|
|
case 0x244:
|
|
case 0x245:
|
|
case 0x247:
|
|
case 0x248:
|
|
case 0x249:
|
|
case 0x24A:
|
|
case 0x297:
|
|
case 0x2D1B:
|
|
case 0x2D37:
|
|
case 0x2D38:
|
|
case 0x2D39:
|
|
case 0x2D3A:
|
|
case 0x2D3B:
|
|
case 0x2D3C:
|
|
case 0x2D3D:
|
|
case 0x2D3E:
|
|
effectId = 7;
|
|
break;
|
|
case 0x20A:
|
|
g_soundMgr->PlayWave("_heal_effect.wav", 0.0f, 0.0f, 0.0f, 250, 40, 1.0f, 0);
|
|
break;
|
|
case 0x20B:
|
|
g_soundMgr->PlayWave("effect\\EF_Blessing.wav", 0.0f, 0.0f, 0.0f, 250, 40, 1.0f, 0);
|
|
break;
|
|
case 0x22A:
|
|
case 0x2F5A:
|
|
case 0x2F5B:
|
|
case 0x2F5C:
|
|
case 0x2FA3:
|
|
case 0x2FA4:
|
|
case 0x2FA5:
|
|
case 0x2FA6:
|
|
case 0x2FCE:
|
|
case 0x2FCF:
|
|
case 0x5817:
|
|
case 0x5818:
|
|
case 0x5819:
|
|
g_soundMgr->PlayWave("_heal_effect.wav", 0.0f, 0.0f, 0.0f, 250, 40, 1.0f, 0);
|
|
effectId = 0x1EB;
|
|
break;
|
|
case 0x22E:
|
|
case 0x231:
|
|
case 0x2D40:
|
|
case 0x2D43:
|
|
case 0x2FCD:
|
|
effectId = 0x16C;
|
|
break;
|
|
case 0x22F:
|
|
case 0x230:
|
|
case 0x2D41:
|
|
case 0x2D42:
|
|
case 0x2DB5:
|
|
effectId = 0x16B;
|
|
break;
|
|
case 0x23D:
|
|
case 0x254:
|
|
case 0x255:
|
|
case 0x2D3F:
|
|
case 0x2FCA:
|
|
effectId = 0x1FD;
|
|
break;
|
|
case 0x23E:
|
|
case 0x3036:
|
|
case 0x3038:
|
|
effectId = 0xD2;
|
|
break;
|
|
case 0x285:
|
|
case 0x38AD:
|
|
case 0x580E:
|
|
effectId = 0xDA;
|
|
break;
|
|
case 0x290:
|
|
case 0x38AE:
|
|
case 0x5810:
|
|
effectId = 0xDB;
|
|
break;
|
|
case 0x291:
|
|
case 0x38AF:
|
|
case 0x580F:
|
|
effectId = 0xDC;
|
|
break;
|
|
case 0x296:
|
|
case 0x2FE6:
|
|
g_soundMgr->PlayWave("effect\\mapae.wav", 0.0f, 0.0f, 0.0f, 250, 40, 1.0f, 0);
|
|
effectId = 0x1FB;
|
|
break;
|
|
case 0x2AC:
|
|
static_cast<EffectActor*>(actor)->LaunchEffect(0x105, vector3d{0.0f, 0.0f, 0.0f}, 0.0f);
|
|
effectId = 0xDC;
|
|
break;
|
|
case 0x2AD:
|
|
effectId = 0x1EC;
|
|
break;
|
|
case 0x2EF0:
|
|
case 0x5811:
|
|
g_soundMgr->PlayWave("effect\\fast.wav", 0.0f, 0.0f, 0.0f, 250, 40, 1.0f, 0);
|
|
effectId = 0x207;
|
|
break;
|
|
case 0x2EF1:
|
|
case 0x5812:
|
|
effectId = 0x26;
|
|
break;
|
|
case 0x2EF2:
|
|
g_soundMgr->PlayWave("effect\\itempokjuk.wav", 0.0f, 0.0f, 0.0f, 250, 40, 1.0f, 0);
|
|
effectId = 0x1FC;
|
|
break;
|
|
case 0x2EF7:
|
|
g_soundMgr->PlayWave("effect\\ro2effect.wav", 0.0f, 0.0f, 0.0f, 250, 40, 1.0f, 0);
|
|
effectId = 0x221;
|
|
break;
|
|
case 0x2EFB:
|
|
case 0x588D:
|
|
g_soundMgr->PlayWave("wraith_die.wav", 0.0f, 0.0f, 0.0f, 250, 40, 1.0f, 0);
|
|
break;
|
|
case 0x2EFC:
|
|
effectId = 0x240;
|
|
break;
|
|
case 0x2EFD:
|
|
effectId = 0x241;
|
|
break;
|
|
case 0x2EFE:
|
|
effectId = 0x242;
|
|
break;
|
|
case 0x2EFF:
|
|
effectId = 0x243;
|
|
break;
|
|
case 0x2F00:
|
|
effectId = 0x244;
|
|
break;
|
|
case 0x2F01:
|
|
effectId = 0x245;
|
|
break;
|
|
case 0x2F02:
|
|
g_soundMgr->PlayWave("ork_warrior_breath.wav", 0.0f, 0.0f, 0.0f, 250, 40, 1.0f, 0);
|
|
break;
|
|
case 0x2F56:
|
|
g_soundMgr->PlayWave("evil_cloud_hermit_attack.wav", 0.0f, 0.0f, 0.0f, 250, 40, 1.0f, 0);
|
|
effectId = 0x25B;
|
|
break;
|
|
case 0x2F57:
|
|
g_soundMgr->PlayWave("evil_cloud_hermit_attack.wav", 0.0f, 0.0f, 0.0f, 250, 40, 1.0f, 0);
|
|
effectId = 0x33;
|
|
break;
|
|
case 0x2F58:
|
|
g_soundMgr->PlayWave("evil_cloud_hermit_attack.wav", 0.0f, 0.0f, 0.0f, 250, 40, 1.0f, 0);
|
|
effectId = 0x93;
|
|
break;
|
|
case 0x2F59:
|
|
g_soundMgr->PlayWave("evil_cloud_hermit_attack.wav", 0.0f, 0.0f, 0.0f, 250, 40, 1.0f, 0);
|
|
effectId = 0x34;
|
|
break;
|
|
case 0x2F63:
|
|
effectId = 0x264;
|
|
break;
|
|
case 0x2FBA:
|
|
static_cast<EffectActor*>(actor)->LaunchEffect(0x177, vector3d{0.0f, 0.0f, 0.0f}, 0.0f);
|
|
static_cast<EffectActor*>(actor)->LaunchEffect(0x1B8, vector3d{0.0f, 0.0f, 0.0f}, 0.0f);
|
|
break;
|
|
case 0x2FDA:
|
|
effectId = 0x251;
|
|
break;
|
|
case 0x2FDB:
|
|
effectId = 0x254;
|
|
break;
|
|
case 0x2FDC:
|
|
effectId = 0x252;
|
|
break;
|
|
case 0x2FDD:
|
|
effectId = 0x255;
|
|
break;
|
|
case 0x2FDE:
|
|
effectId = 0x256;
|
|
break;
|
|
case 0x2FDF:
|
|
effectId = 0x253;
|
|
break;
|
|
case 0x3016:
|
|
case 0x3017:
|
|
effectId = 0x2BB;
|
|
break;
|
|
case 0x301B:
|
|
effectId = 0x152;
|
|
break;
|
|
case 0x301C:
|
|
effectId = 0x2C1;
|
|
break;
|
|
case 0x301D:
|
|
g_soundMgr->PlayWave("effect\\storm.wav", 0.0f, 0.0f, 0.0f, 250, 40, 1.0f, 0);
|
|
effectId = 0x2C2;
|
|
break;
|
|
case 0x301E:
|
|
effectId = 0x2C3;
|
|
break;
|
|
case 0x3026:
|
|
g_soundMgr->PlayWave("effect\\pokjuk_jap.wav", 0.0f, 0.0f, 0.0f, 250, 40, 1.0f, 0);
|
|
effectId = 0x2C5;
|
|
break;
|
|
case 0x3198:
|
|
g_soundMgr->PlayWave("effect\\itempokjuk.wav", 0.0f, 0.0f, 0.0f, 250, 40, 1.0f, 0);
|
|
effectId = 0x3DB;
|
|
break;
|
|
case 0x3199:
|
|
g_soundMgr->PlayWave("effect\\itempokjuk.wav", 0.0f, 0.0f, 0.0f, 250, 40, 1.0f, 0);
|
|
effectId = 0x3DC;
|
|
break;
|
|
case 0x31F4:
|
|
g_soundMgr->PlayWave("effect\\itempokjuk.wav", 0.0f, 0.0f, 0.0f, 250, 40, 1.0f, 0);
|
|
effectId = 0x3EE;
|
|
break;
|
|
case 0x3280:
|
|
effectId = 0x56;
|
|
break;
|
|
case 0x38D2:
|
|
effectId = 0x2AA;
|
|
break;
|
|
case 0x38D3:
|
|
effectId = 0x2AB;
|
|
break;
|
|
case 0x38D4:
|
|
effectId = 0x2AC;
|
|
break;
|
|
case 0x38D5:
|
|
effectId = 0x2AD;
|
|
break;
|
|
case 0x38D6:
|
|
effectId = 0x2AE;
|
|
break;
|
|
case 0x18733:
|
|
case 0x18734:
|
|
case 0x18735:
|
|
effectId = 0x63D;
|
|
secondEffectId = 0x63E;
|
|
break;
|
|
case 0x18736:
|
|
effectId = 0x63B;
|
|
secondEffectId = 0x63C;
|
|
break;
|
|
case 0x19605:
|
|
effectId = 0x982;
|
|
break;
|
|
}
|
|
|
|
if ((itemId >= 0x2F09 && itemId <= 0x2F0D) || (itemId >= 0x2F27 && itemId <= 0x2F2B) || itemId == 0x2FAA) {
|
|
effectId = 0x251;
|
|
} else if ((itemId >= 0x2F0E && itemId <= 0x2F12) || (itemId >= 0x2F2C && itemId <= 0x2F30) || itemId == 0x2FAC) {
|
|
effectId = 0x252;
|
|
} else if ((itemId >= 0x2F13 && itemId <= 0x2F17) || (itemId >= 0x2F31 && itemId <= 0x2F35) || itemId == 0x2FAF) {
|
|
effectId = 0x253;
|
|
} else if ((itemId >= 0x2F18 && itemId <= 0x2F1C) || (itemId >= 0x2F36 && itemId <= 0x2F3A) || itemId == 0x2FAB) {
|
|
effectId = 0x254;
|
|
} else if ((itemId >= 0x2F1D && itemId <= 0x2F21) || (itemId >= 0x2F3B && itemId <= 0x2F3F) || itemId == 0x2FAD) {
|
|
effectId = 0x255;
|
|
} else if ((itemId >= 0x2F22 && itemId <= 0x2F26) || (itemId >= 0x2F40 && itemId <= 0x2F44) || itemId == 0x2FAE) {
|
|
effectId = 0x256;
|
|
}
|
|
|
|
if (effectId > 0) {
|
|
while (static_cast<EffectActor*>(actor)->state.Attachments().HasId(effectId)) {
|
|
actor->SendMsg(nullptr, 109, 0, effectId, effectId >> 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
|
|
}
|
|
if (g_effectMgr->HasAllocator(effectId)) {
|
|
g_effectMgr->Spawn(actor->render.accountId, effectId, 0.0f, 0.0f, 0.0f, 0, -1, 0, 0);
|
|
} else {
|
|
static_cast<EffectActor*>(actor)->LaunchEffect(effectId, vector3d{0.0f, 0.0f, 0.0f}, 0.0f);
|
|
}
|
|
}
|
|
|
|
if (secondEffectId > 0) {
|
|
while (static_cast<EffectActor*>(actor)->state.Attachments().HasId(secondEffectId)) {
|
|
actor->SendMsg(nullptr, 109, 0, secondEffectId, secondEffectId >> 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
|
|
}
|
|
if (g_effectMgr->HasAllocator(secondEffectId)) {
|
|
g_effectMgr->Spawn(actor->render.accountId, secondEffectId, 0.0f, 0.0f, 0.0f, 0, -1, 0, 0);
|
|
} else {
|
|
static_cast<EffectActor*>(actor)->LaunchEffect(secondEffectId, vector3d{0.0f, 0.0f, 0.0f}, 0.0f);
|
|
}
|
|
}
|
|
}
|
|
|
|
#include "ActorPickNode.h"
|
|
#include "Client/Input/Mouse.h"
|
|
#include "Client/Mode/CLoginMode.h"
|
|
#include "Client/Mode/ModeTooltip.h"
|
|
#include "Client/Registry.h"
|
|
#include "Contents/ClientItemLists.h"
|
|
#include "Contents/Effects/EffectPrim.h"
|
|
#include "Contents/MapSkyMgr.h"
|
|
#include "Contents/NavigationManager.h"
|
|
#include "Contents/SignBoard/SignBoard.h"
|
|
#include "Contents/Sound/SoundMaker.h"
|
|
#include "Contents/TerrainPathSearch.h"
|
|
#include "Contents/UserData/AccountLinkedUserDataMgr.h"
|
|
#include "Network/GameTickPacket.h"
|
|
#include "UI/Buttons/UITextButton.h"
|
|
#include "UI/Layout/SnapMgr.h"
|
|
#include "UI/Window/UIMileageWnd.h"
|
|
#include "UI/Window/UIWindowFactory.h"
|
|
#include <list>
|
|
#include <new>
|
|
#include <winsock2.h>
|
|
#include <windows.h>
|
|
|
|
struct SessionMessengerContext {
|
|
void UpdateRandomStats();
|
|
};
|
|
|
|
struct SessionItemLists {
|
|
void ClearTradeItems();
|
|
};
|
|
|
|
// GLOBAL: gl_24776
|
|
int g_visibleMinX;
|
|
|
|
// GLOBAL: gl_24777
|
|
int g_visibleMinY;
|
|
|
|
// GLOBAL: gl_24778
|
|
int g_visibleMaxX;
|
|
|
|
// GLOBAL: gl_24779
|
|
int g_visibleMaxY;
|
|
|
|
// GLOBAL: gl_25330
|
|
std::uint32_t g_gameTickInterval = 12000;
|
|
|
|
// GLOBAL: gl_25332
|
|
int g_window315Enabled = 1;
|
|
|
|
// OFFSET: 0x00CD5E90
|
|
// FUNCTION: fn_21288
|
|
void CGameMode::InitializeState() {
|
|
reinterpret_cast<ModeTooltip*>(this)->Clear();
|
|
this->nameCard.Clear();
|
|
this->unknown_019C.clear();
|
|
this->unknown_01A4.clear();
|
|
this->actorMenuIds.clear();
|
|
this->unknown_01B4.clear();
|
|
this->unknown_01C4.clear();
|
|
this->m_skillUnitIds.clear();
|
|
this->spriteMirrorActorIds.clear();
|
|
this->minimapMarkers.clear();
|
|
|
|
if (g_windowMgr.window_4F1CC) {
|
|
g_windowMgr.window_4F1CC->SendMsg(nullptr, 486, 0, 0, 0, 0);
|
|
}
|
|
|
|
g_snapMgr.Clear();
|
|
g_windowMgr.sub_AA6B80();
|
|
this->broadcastBalloon = nullptr;
|
|
this->noticeBalloon = nullptr;
|
|
g_windowMgr.SetSurface0478(nullptr);
|
|
g_windowMgr.EnsureWindow(0);
|
|
g_windowMgr.ShowWindowsWithId(67, 1);
|
|
g_windowMgr.EnsureWindow(204);
|
|
|
|
const char* worldName = reinterpret_cast<const char*>(g_modeMgr.GetGameMode()->SendMsg(9, 0, 0, 0, 0));
|
|
if (std::strcmp(worldName, "new_event.rsw") != 0) {
|
|
g_windowMgr.EnsureWindow(190);
|
|
}
|
|
|
|
if (g_closeWindow137State) {
|
|
g_windowMgr.EnsureWindow(137);
|
|
}
|
|
|
|
if (!g_replayAnimationScaling && g_serviceOptions.Get(270)) {
|
|
g_windowMgr.EnsureWindow(159);
|
|
}
|
|
|
|
if (g_closeWindow164State) {
|
|
g_windowMgr.EnsureWindow(164);
|
|
}
|
|
|
|
if (g_searchStoreInfoCreated) {
|
|
g_windowMgr.EnsureWindow(181);
|
|
}
|
|
|
|
g_windowMgr.EnsureWindow(268);
|
|
if (g_refreshWindow289) {
|
|
g_windowMgr.EnsureWindow(289);
|
|
}
|
|
|
|
this->running = 1;
|
|
g_visibleMinX = 0;
|
|
g_visibleMaxX = 0;
|
|
g_visibleMinY = 0;
|
|
g_visibleMaxY = 0;
|
|
ActorPickBounds bounds;
|
|
bounds.left = 0;
|
|
bounds.top = 0;
|
|
bounds.right = g_renderer->viewport.width;
|
|
bounds.bottom = g_renderer->viewport.height;
|
|
g_actorPickNode.MakeQuardTree(1, bounds);
|
|
g_pathFinder.attr = this->scene->terrain;
|
|
g_navigationManager.UpdateGround();
|
|
g_overrideColor = 0;
|
|
|
|
this->unknown_0010 = 1;
|
|
this->cursorOffsetX = 0.0f;
|
|
this->cursorOffsetY = 0.0f;
|
|
*reinterpret_cast<int*>(this->unknown_00D8) = 0;
|
|
*reinterpret_cast<int*>(&this->unknown_00D8[4]) = g_screenWidth;
|
|
*reinterpret_cast<int*>(&this->unknown_00D8[8]) = g_screenHeight;
|
|
this->unknown_00E4 = g_screenWidth;
|
|
this->unknown_00E8 = g_screenHeight;
|
|
*reinterpret_cast<int*>(&this->unknown_01F8[0x4C]) = 0;
|
|
this->unknown_024C = 0;
|
|
this->unknown_0250 = 0;
|
|
*reinterpret_cast<int*>(&this->unknown_0294[0x18]) = 0;
|
|
*reinterpret_cast<int*>(&this->unknown_0294[0x1C]) = 0;
|
|
*reinterpret_cast<int*>(this->unknown_02B8) = 0;
|
|
*reinterpret_cast<int*>(&this->unknown_02B8[4]) = 0;
|
|
*reinterpret_cast<int*>(&this->unknown_02B8[8]) = 0;
|
|
this->itemWindow = nullptr;
|
|
this->unknown_05D0 = nullptr;
|
|
*reinterpret_cast<int*>(this->unknown_01F8) = -1;
|
|
this->balloonActorId = 0;
|
|
*reinterpret_cast<int*>(this->unknown_02E4) = 0;
|
|
*reinterpret_cast<int*>(&this->unknown_02E4[4]) = 0;
|
|
*reinterpret_cast<int*>(&this->unknown_02B8[0x0C]) = 1;
|
|
*reinterpret_cast<int*>(&this->unknown_02B8[0x10]) = 1;
|
|
this->unknown_02CC = 0;
|
|
*reinterpret_cast<int*>(this->unknown_02D0) = 0;
|
|
this->unknown_02D4 = 0;
|
|
this->drag.Clear();
|
|
this->unknown_02DC = 0;
|
|
this->unknown_02E0 = 0;
|
|
*reinterpret_cast<int*>(this->unknown_00EC) = 0;
|
|
*reinterpret_cast<int*>(&this->unknown_00EC[4]) = 0;
|
|
*reinterpret_cast<int*>(&this->unknown_00EC[8]) = 0;
|
|
*reinterpret_cast<int*>(&this->unknown_00EC[0x0C]) = 1;
|
|
this->unknown_00FC = 0;
|
|
*reinterpret_cast<int*>(this->unknown_0100) = 0;
|
|
*reinterpret_cast<std::uint32_t*>(&this->unknown_0100[0x04]) = timeGetTime() - 2000;
|
|
*reinterpret_cast<std::uint32_t*>(&this->unknown_0100[0x08]) = timeGetTime() - 2000;
|
|
*reinterpret_cast<int*>(&this->unknown_0100[0x0C]) = 0;
|
|
*reinterpret_cast<int*>(&this->unknown_0100[0x10]) = 0;
|
|
*reinterpret_cast<int*>(&this->unknown_0100[0x14]) = 0;
|
|
*reinterpret_cast<int*>(&this->unknown_0418[0x38]) = 0;
|
|
*reinterpret_cast<int*>(&this->unknown_0418[0x3C]) = 0;
|
|
*reinterpret_cast<std::string*>(&this->unknown_0418[0x20]) = "";
|
|
this->unknown_0408 = nullptr;
|
|
this->unknown_040C = 0;
|
|
g_pickInvert = 0;
|
|
*reinterpret_cast<int*>(this->unknown_045C) = 0;
|
|
*reinterpret_cast<int*>(&this->unknown_0418[4]) = -1;
|
|
*reinterpret_cast<int*>(&this->unknown_045C[4]) = -1;
|
|
|
|
char subKey[512];
|
|
std::strcpy(subKey, g_subKey);
|
|
std::strcat(subKey, "\\NameBaloon");
|
|
std::strcat(subKey, "\\");
|
|
std::strcat(subKey, g_session.m_serverName.c_str());
|
|
HKEY key;
|
|
if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, subKey, 0, KEY_QUERY_VALUE, &key) == ERROR_SUCCESS) {
|
|
RegCloseKey(key);
|
|
HKEY valueKey;
|
|
if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, subKey, 0, KEY_ALL_ACCESS, &valueKey) == ERROR_SUCCESS) {
|
|
DWORD position = 0;
|
|
DWORD type = REG_DWORD;
|
|
DWORD size = sizeof(position);
|
|
RegQueryValueExA(valueKey, "POS", nullptr, &type, reinterpret_cast<BYTE*>(&position), &size);
|
|
g_serviceOptions.Set(92, position == 1);
|
|
RegCloseKey(valueKey);
|
|
}
|
|
}
|
|
|
|
g_mouse.Reset();
|
|
*reinterpret_cast<int*>(&this->unknown_026E[0x02]) = 1;
|
|
this->unknown_026E[0x16] = 0;
|
|
*reinterpret_cast<std::uint32_t*>(&this->unknown_026E[0x06]) = timeGetTime();
|
|
*reinterpret_cast<std::uint32_t*>(&this->unknown_026E[0x0A]) = timeGetTime();
|
|
*reinterpret_cast<std::uint32_t*>(&this->unknown_01F8[0x50]) = timeGetTime();
|
|
*reinterpret_cast<std::uint32_t*>(this->unknown_01E0) = timeGetTime();
|
|
this->broadcastBalloon = nullptr;
|
|
*reinterpret_cast<std::uint32_t*>(&this->unknown_026E[0x0E]) = timeGetTime();
|
|
*reinterpret_cast<std::uint32_t*>(&this->unknown_026E[0x12]) = timeGetTime();
|
|
this->unknown_05CE = 1;
|
|
std::memset(&this->unknown_05EC[1], 0, 6);
|
|
*reinterpret_cast<int*>(&this->unknown_05EC[0x08]) = 0;
|
|
*reinterpret_cast<int*>(&this->unknown_05EC[0x0C]) = 0;
|
|
g_soundMgr->SetListenerYaw(this->camera->camera.desiredYaw);
|
|
this->SendMsg(41, 0, 0, 0, 0);
|
|
|
|
if (g_isStopByLogin) {
|
|
g_isStopByLogin = 0;
|
|
reinterpret_cast<GuildInfo*>(reinterpret_cast<char*>(&g_guildId) - offsetof(GuildInfo, m_guildId))->Init();
|
|
g_windowMgr.SendNotice(3, 0, 0, 0, 0, 0);
|
|
g_windowMgr.SendNotice(1, reinterpret_cast<std::intptr_t>(LookupMessage(22)), 0xFFE6E6, 0, 0, 0);
|
|
inet_ntoa(*reinterpret_cast<const in_addr*>(&g_session.unknown_0E9C[0x10]));
|
|
if (!g_accountLinkedUserDataMgr->m_loaded) {
|
|
g_windowMgr.SendNotice(1, reinterpret_cast<std::intptr_t>(LookupMessage(3457)), 255, 0, 0, 0);
|
|
}
|
|
}
|
|
|
|
reinterpret_cast<ClientItemLists*>(&g_session)->ResetUnknown166C();
|
|
reinterpret_cast<SessionMessengerContext*>(&g_session)->UpdateRandomStats();
|
|
reinterpret_cast<ClientItemLists*>(&g_session)->ClearItems1738();
|
|
reinterpret_cast<SessionItemLists*>(&g_session)->ClearTradeItems();
|
|
reinterpret_cast<ClientItemLists*>(&g_session)->ClearItems1768();
|
|
reinterpret_cast<ClientItemLists*>(&g_session)->ClearItems1758();
|
|
reinterpret_cast<ClientItemLists*>(&g_session)->ClearItems1750();
|
|
|
|
// GLOBAL: gl_25334
|
|
static int s_window315Checked;
|
|
if (!g_replayAnimationScaling && !s_window315Checked) {
|
|
s_window315Checked = 1;
|
|
if (g_window315Enabled) {
|
|
g_windowMgr.EnsureWindow(315);
|
|
}
|
|
}
|
|
|
|
if (g_replayAnimationScaling != 1) {
|
|
std::int16_t packet = 0x7D;
|
|
GetRagConnection().Send(2, &packet);
|
|
GetRagConnection().ResetDeferred();
|
|
g_session.SetOption(5, 1, 0);
|
|
}
|
|
|
|
SendGameTick(
|
|
true, *reinterpret_cast<std::uint32_t*>(&this->unknown_026E[0x02]), *reinterpret_cast<std::uint32_t*>(&this->unknown_026E[0x06]), g_gameTickInterval,
|
|
GetRagConnection(), g_packetLengths, g_pingLogEnabled, g_pingLogFirstTick, g_pingLogTicks
|
|
);
|
|
g_weatherEffect.ResetEffect();
|
|
g_weatherEffect.ApplyMapWeather(this->mapName);
|
|
if (std::strcmp(this->mapName, "xmas_fild01.rsw") == 0 || std::strcmp(this->mapName, "xmas.rsw") == 0) {
|
|
if (g_serviceOptions.Get(8)) {
|
|
g_weatherEffect.Snow();
|
|
} else {
|
|
g_weatherEffect.ExtendEffect();
|
|
}
|
|
}
|
|
|
|
if (!g_mapSkyMgr) {
|
|
g_mapSkyMgr = new (std::nothrow) CMapSkyMgr;
|
|
}
|
|
|
|
g_mapSkyMgr->Apply(this->mapName);
|
|
if ((g_serviceType == 8 || g_serviceType == 9) && std::strcmp(this->mapName, "comodo.rsw") == 0 && g_serviceOptions.Get(8)) {
|
|
g_weatherEffect.Fireworks();
|
|
}
|
|
|
|
*reinterpret_cast<int*>(&g_session.unknown_5570[0x08]) = -1;
|
|
g_groundMarkEnabled = 0;
|
|
g_session.ClearHomunStatus();
|
|
*reinterpret_cast<int*>(&g_session.unknown_5620[0x08]) = -1;
|
|
g_groundMarkAltEnabled = 0;
|
|
g_session.ResetMercenaryStats();
|
|
g_windowMgr.FocusWindow01C8Edit();
|
|
|
|
g_windowMgr.window_4F168 = nullptr;
|
|
const int replayState = Replay::Instance().state;
|
|
if (g_replayAnimationScaling) {
|
|
g_windowMgr.EnsureWindow(187);
|
|
if (replayState == 8) {
|
|
g_windowMgr.window_4F168->SendMsg(nullptr, 35, 0, 0, 0, 0);
|
|
}
|
|
}
|
|
|
|
if (replayState == 3) {
|
|
Replay::Instance().SetState(2);
|
|
g_windowMgr.EnsureWindow(198);
|
|
g_windowMgr.window_4F164->Move(Replay::Instance().unknown_01F4, Replay::Instance().unknown_01F8);
|
|
g_windowMgr.window_4F164->SendMsg(nullptr, 123, 0, 0, 0, 0);
|
|
} else if (replayState == 8) {
|
|
Replay::Instance().SetState(7);
|
|
}
|
|
|
|
g_navigationManager.ResumeRoute();
|
|
if (g_mileageWndActive) {
|
|
UIWindow* mileage = g_windowMgr.EnsureWindow(267);
|
|
if (mileage) {
|
|
mileage->SendMsg(nullptr, 34, g_mileageWndActive, g_mileageWndPoint, g_mileageWndElapsed, g_mileageWndBonus);
|
|
}
|
|
}
|
|
|
|
this->unknown_05FC = nullptr;
|
|
*reinterpret_cast<int*>(this->unknown_0600) = 0;
|
|
s_signBoardMgr->Initialize();
|
|
g_statusRefreshSuppressed = 0;
|
|
int& localMapMove = *reinterpret_cast<int*>(&g_session.unknown_61A8[4]);
|
|
if (localMapMove == 1) {
|
|
localMapMove = 0;
|
|
}
|
|
|
|
reinterpret_cast<GuildInfo*>(reinterpret_cast<char*>(&g_guildId) - offsetof(GuildInfo, m_guildId))->ClearUnknown0114();
|
|
this->unknown_02EC = "";
|
|
}
|
|
|
|
// OFFSET: 0x00CE46B0
|
|
// FUNCTION: fn_21337
|
|
void CGameMode::ProcessRightButtonDrag() {
|
|
switch (g_mouse.buttons[1]) {
|
|
case 1: {
|
|
if (g_windowMgr.unknown_0210) {
|
|
g_windowMgr.CloseWindow(0x12);
|
|
}
|
|
|
|
this->SendMsg(0x12, 0, 0, 0, 0);
|
|
this->SendMsg(0x47, 0, 0, 0, 0);
|
|
this->unknown_00E4 = g_screenWidth;
|
|
this->unknown_00E8 = g_screenHeight;
|
|
if (!g_serviceOptions.Get(0x78)) {
|
|
return;
|
|
}
|
|
|
|
UIShortCutWnd* shortcuts = static_cast<UIShortCutWnd*>(g_windowMgr.window_01E8);
|
|
if (!shortcuts) {
|
|
return;
|
|
}
|
|
|
|
AutomaticSkills* automatic = reinterpret_cast<AutomaticSkills*>(g_session.unknown_7FB4);
|
|
if (shortcuts->m_slots[4]->unknown_0000 && automatic->Contains(static_cast<std::uint16_t>(shortcuts->m_slots[4]->itemId))) {
|
|
g_session.SetOption(AutomaticSkills::CancelOption(static_cast<std::int16_t>(shortcuts->m_slots[4]->itemId)), 1, 0);
|
|
} else {
|
|
automatic->DisableAll();
|
|
}
|
|
|
|
shortcuts->SendMsg(nullptr, 0x29, 8, 0, 0, 0);
|
|
return;
|
|
}
|
|
case 2:
|
|
if (!HIBYTE(GetAsyncKeyState(VK_MENU)) && !HIBYTE(GetAsyncKeyState(VK_SHIFT))) {
|
|
reinterpret_cast<ModeCursor*>(&this->cursorAction)->Set(4, this->cursorTick);
|
|
if (this->hasViewParameters) {
|
|
float yaw = static_cast<float>(g_screenWidth) + this->camera->camera.desiredYaw - static_cast<float>(this->unknown_00DC);
|
|
const float low = static_cast<float>(this->viewParameters[3]);
|
|
const float high = static_cast<float>(this->viewParameters[4]);
|
|
if (yaw < low) {
|
|
yaw = low;
|
|
}
|
|
if (yaw > high) {
|
|
yaw = high;
|
|
}
|
|
this->camera->camera.desiredYaw = yaw;
|
|
} else if (this->unknown_0254 == 0 && g_session.IsAdminSubMode(6) == 0) {
|
|
float yaw = static_cast<float>(g_screenWidth) + this->camera->camera.desiredYaw - static_cast<float>(this->unknown_00DC);
|
|
const float low = this->unknown_0288 - 20.0f;
|
|
const float high = this->unknown_0288 + 20.0f;
|
|
if (yaw < low) {
|
|
yaw = low;
|
|
}
|
|
if (yaw > high) {
|
|
yaw = high;
|
|
}
|
|
this->camera->camera.desiredYaw = yaw;
|
|
} else {
|
|
this->camera->camera.AddYaw(static_cast<float>(g_screenWidth - this->unknown_00DC));
|
|
}
|
|
|
|
g_soundMgr->SetListenerYaw(this->camera->camera.desiredYaw);
|
|
}
|
|
|
|
if (!HIBYTE(GetAsyncKeyState(VK_MENU)) && HIBYTE(GetAsyncKeyState(VK_SHIFT))) {
|
|
const float range = this->unknown_0254 ? 42.0f : 10.0f;
|
|
g_cameraPitch = this->camera->camera.desiredPitch - static_cast<float>((g_screenHeight - this->unknown_00E0) / 2);
|
|
float limit;
|
|
if (this->hasViewParameters) {
|
|
if (g_cameraPitch < static_cast<float>(this->viewParameters[7])) {
|
|
g_cameraPitch = static_cast<float>(this->viewParameters[7]);
|
|
}
|
|
limit = static_cast<float>(this->viewParameters[6]);
|
|
} else {
|
|
if (g_cameraPitch < -45.0f - range) {
|
|
g_cameraPitch = -45.0f - range;
|
|
}
|
|
if (HIBYTE(GetAsyncKeyState(VK_CONTROL)) && this->camera->camera.desiredDistance <= g_serviceOptionJitterScale) {
|
|
limit = range - 45.0f;
|
|
} else {
|
|
limit = range - 70.0f;
|
|
}
|
|
}
|
|
|
|
if (g_cameraPitch > limit) {
|
|
g_cameraPitch = limit;
|
|
}
|
|
this->camera->camera.desiredPitch = g_cameraPitch;
|
|
}
|
|
|
|
if (HIBYTE(GetAsyncKeyState(VK_CONTROL))) {
|
|
g_cameraDistance = this->camera->camera.desiredDistance - static_cast<float>((g_screenHeight - this->unknown_00E0) / 2);
|
|
float maxDistance = this->unknown_0254 ? g_serviceOptionJitterScale : g_cameraBaseDistance;
|
|
if (this->hasViewParameters) {
|
|
if (g_cameraDistance < static_cast<float>(this->viewParameters[0])) {
|
|
g_cameraDistance = static_cast<float>(this->viewParameters[0]);
|
|
}
|
|
maxDistance = static_cast<float>(this->viewParameters[1] + this->viewParameters[0]);
|
|
if (g_cameraDistance > maxDistance) {
|
|
g_cameraDistance = maxDistance;
|
|
}
|
|
} else if (g_session.IsAdminSubMode(5) == 0) {
|
|
if (g_cameraDistance < g_cameraMinDistance) {
|
|
g_cameraDistance = g_cameraMinDistance;
|
|
}
|
|
if (g_cameraDistance > maxDistance) {
|
|
g_cameraDistance = maxDistance;
|
|
}
|
|
}
|
|
|
|
this->camera->camera.desiredDistance = g_cameraDistance;
|
|
}
|
|
return;
|
|
case 4:
|
|
if (this->hasViewParameters) {
|
|
return;
|
|
}
|
|
|
|
if (HIBYTE(GetAsyncKeyState(VK_CONTROL))) {
|
|
this->camera->camera.desiredDistance = g_cameraBaseDistance;
|
|
}
|
|
if (HIBYTE(GetAsyncKeyState(VK_SHIFT))) {
|
|
this->camera->camera.desiredPitch = -50.0f;
|
|
}
|
|
if (!g_serviceOptions.Get(0x78) && this->unknown_0254 && !HIBYTE(GetAsyncKeyState(VK_SHIFT)) && !HIBYTE(GetAsyncKeyState(VK_CONTROL))) {
|
|
this->camera->camera.desiredYaw = 0.0f;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00CE7CE0
|
|
// FUNCTION: fn_21339
|
|
void CGameMode::ProcessMouseWheel(int requireControl) {
|
|
if (timeGetTime() - this->wheelTick < 16) {
|
|
return;
|
|
}
|
|
|
|
this->wheelTick = timeGetTime();
|
|
if (g_mouse.wheel == 0 || this->unknown_0408 != nullptr) {
|
|
return;
|
|
}
|
|
|
|
ClientSkills skills{
|
|
g_session.m_skillBundle,
|
|
g_session.m_homunSkills,
|
|
g_session.m_mercSkills,
|
|
g_session.m_additionalSkills,
|
|
reinterpret_cast<const int&>(g_session.m_jobFlags),
|
|
g_activeSkillEffects
|
|
};
|
|
CSkillInfo wheelSkill = skills.bundle.Lookup(0x27F, skills.classMode, skills.HasEffect(1717), skills.HasEffect(1716));
|
|
if (wheelSkill.level > 0) {
|
|
const int count = this->unknown_05F4;
|
|
if (count > this->unknown_05F8) {
|
|
this->unknown_05F8 = count;
|
|
}
|
|
this->unknown_05F4 = count + 4;
|
|
}
|
|
|
|
if (HIBYTE(GetAsyncKeyState(VK_SHIFT))) {
|
|
const float step = g_mouse.wheel > 0 ? -5.0f : 5.0f;
|
|
const float range = this->unknown_0254 ? 20.0f : 10.0f;
|
|
g_cameraPitch = this->camera->camera.desiredPitch - step;
|
|
float limit;
|
|
if (this->hasViewParameters) {
|
|
if (g_cameraPitch < static_cast<float>(this->viewParameters[7])) {
|
|
g_cameraPitch = static_cast<float>(this->viewParameters[7]);
|
|
}
|
|
limit = static_cast<float>(this->viewParameters[6]);
|
|
} else {
|
|
if (g_cameraPitch < -45.0f - range) {
|
|
g_cameraPitch = -45.0f - range;
|
|
}
|
|
if (HIBYTE(GetAsyncKeyState(VK_CONTROL)) && this->camera->camera.desiredDistance <= g_serviceOptionJitterScale) {
|
|
limit = range - 45.0f;
|
|
} else {
|
|
limit = range - 70.0f;
|
|
}
|
|
}
|
|
|
|
if (g_cameraPitch > limit) {
|
|
g_cameraPitch = limit;
|
|
}
|
|
this->camera->camera.desiredPitch = g_cameraPitch;
|
|
return;
|
|
}
|
|
|
|
if (requireControl != 0 && !HIBYTE(GetAsyncKeyState(VK_CONTROL))) {
|
|
return;
|
|
}
|
|
|
|
if (g_serviceOptions.Get(0x79)) {
|
|
UIShortCutWnd* shortcuts = static_cast<UIShortCutWnd*>(g_windowMgr.window_01E8);
|
|
*reinterpret_cast<int*>(&g_session.unknown_544C[0x00]) = 1;
|
|
AutomaticSkills* automatic = reinterpret_cast<AutomaticSkills*>(g_session.unknown_7FB4);
|
|
if (g_mouse.wheel > 0) {
|
|
if (!shortcuts) {
|
|
return;
|
|
}
|
|
|
|
if (shortcuts->m_slots[3]->unknown_0000 && automatic->Contains(shortcuts->m_slots[3]->itemId)) {
|
|
g_session.SetOption(AutomaticSkills::CancelOption(static_cast<std::int16_t>(shortcuts->m_slots[3]->itemId)), 1, 0);
|
|
} else {
|
|
automatic->DisableAll();
|
|
}
|
|
|
|
shortcuts->SendMsg(nullptr, 0x29, 7, 0, 0, 0);
|
|
} else {
|
|
if (!shortcuts) {
|
|
return;
|
|
}
|
|
|
|
if (shortcuts->m_slots[2]->unknown_0000 && automatic->Contains(shortcuts->m_slots[2]->itemId)) {
|
|
g_session.SetOption(AutomaticSkills::CancelOption(static_cast<std::int16_t>(shortcuts->m_slots[2]->itemId)), 1, 0);
|
|
} else {
|
|
automatic->DisableAll();
|
|
}
|
|
|
|
shortcuts->SendMsg(nullptr, 0x29, 6, 0, 0, 0);
|
|
}
|
|
return;
|
|
}
|
|
|
|
const float step = g_mouse.wheel > 0 ? -24.3f : 24.3f;
|
|
g_cameraDistance = this->camera->camera.desiredDistance - step;
|
|
float maxDistance = this->unknown_0254 ? g_serviceOptionJitterScale : g_cameraBaseDistance;
|
|
CSkillInfo zoomSkill = skills.bundle.Lookup(0x1B9, skills.classMode, skills.HasEffect(1717), skills.HasEffect(1716));
|
|
bool extendedZoom = false;
|
|
if (this->hasViewParameters) {
|
|
if (g_cameraDistance < static_cast<float>(this->viewParameters[0])) {
|
|
g_cameraDistance = static_cast<float>(this->viewParameters[0]);
|
|
}
|
|
maxDistance = static_cast<float>(this->viewParameters[1] + this->viewParameters[0]);
|
|
} else if (zoomSkill.level <= 0 && this->scene->player->render.unknown_0070 == 6 && !this->scene->player->state.Attachments().HasId(0x14E)) {
|
|
switch (g_session.m_job) {
|
|
case 0xFCF:
|
|
case 0x1082:
|
|
case 0x108F:
|
|
case 0x1091:
|
|
case 0x10CE:
|
|
extendedZoom = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (extendedZoom) {
|
|
if (g_cameraDistance < g_cameraMinDistance) {
|
|
g_cameraDistance = g_cameraMinDistance;
|
|
}
|
|
if (g_cameraDistance > maxDistance * 3.0f) {
|
|
g_cameraDistance = maxDistance * 3.0f;
|
|
}
|
|
if (g_cameraDistance > maxDistance && this->camera->camera.desiredPitch > -50.0f) {
|
|
this->camera->camera.desiredPitch = -50.0f;
|
|
}
|
|
} else {
|
|
if (!this->hasViewParameters && g_cameraDistance < g_cameraMinDistance) {
|
|
g_cameraDistance = g_cameraMinDistance;
|
|
}
|
|
if (g_cameraDistance > maxDistance) {
|
|
g_cameraDistance = maxDistance;
|
|
}
|
|
}
|
|
|
|
this->camera->camera.desiredDistance = g_cameraDistance;
|
|
}
|