9
3

ClientPacketFunctions.cpp 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402
  1. /*
  2. EQ2Emulator: Everquest II Server Emulator
  3. Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net)
  4. This file is part of EQ2Emulator.
  5. EQ2Emulator is free software: you can redistribute it and/or modify
  6. it under the terms of the GNU General Public License as published by
  7. the Free Software Foundation, either version 3 of the License, or
  8. (at your option) any later version.
  9. EQ2Emulator is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. GNU General Public License for more details.
  13. You should have received a copy of the GNU General Public License
  14. along with EQ2Emulator. If not, see <http://www.gnu.org/licenses/>.
  15. */
  16. #include "ClientPacketFunctions.h"
  17. #include "WorldDatabase.h"
  18. #include "../common/ConfigReader.h"
  19. #include "Variables.h"
  20. #include "World.h"
  21. #include "classes.h"
  22. #include "../common/Log.h"
  23. #include "Traits/Traits.h"
  24. extern Classes classes;
  25. extern Commands commands;
  26. extern WorldDatabase database;
  27. extern ConfigReader configReader;
  28. extern MasterSpellList master_spell_list;
  29. extern MasterTraitList master_trait_list;
  30. extern Variables variables;
  31. extern World world;
  32. void ClientPacketFunctions::SendFinishedEntitiesList ( Client* client ){
  33. EQ2Packet* finishedEntitiesApp = new EQ2Packet(OP_DoneSendingInitialEntitiesMsg, 0, 0);
  34. client->QueuePacket(finishedEntitiesApp);
  35. }
  36. void ClientPacketFunctions::SendSkillSlotMappings(Client* client){
  37. EQ2Packet* app = client->GetPlayer()->GetSpellSlotMappingPacket(client->GetVersion());
  38. if(app)
  39. client->QueuePacket(app);
  40. }
  41. void ClientPacketFunctions::SendLoginDenied ( Client* client ){
  42. PacketStruct* packet = configReader.getStruct("LS_LoginResponse", 1);
  43. if(packet){
  44. packet->setDataByName("reply_code", 1);
  45. packet->setDataByName("unknown03", 0xFFFFFFFF);
  46. packet->setDataByName("unknown04", 0xFFFFFFFF);
  47. EQ2Packet* app = packet->serialize();
  48. client->QueuePacket(app);
  49. safe_delete(packet);
  50. }
  51. }
  52. void ClientPacketFunctions::SendLoginAccepted ( Client* client ){
  53. LogWrite(PACKET__DEBUG, 0, "Packet", "Sending Login Accepted packet (LS_LoginResponse, %i)", client->GetVersion());
  54. PacketStruct* response_packet = configReader.getStruct("LS_LoginResponse", client->GetVersion());
  55. if(response_packet){
  56. response_packet->setDataByName("unknown02", 1);
  57. response_packet->setDataByName("unknown05", -959971393);
  58. response_packet->setDataByName("unknown08", 2);
  59. response_packet->setDataByName("unknown09", 585);
  60. response_packet->setDataByName("unknown10", 1597830);
  61. response_packet->setDataByName("accountid", 3); //client->GetAccountID());
  62. EQ2Packet* outapp = response_packet->serialize();
  63. client->QueuePacket(outapp);
  64. safe_delete(response_packet);
  65. }
  66. }
  67. void ClientPacketFunctions::SendCommandList ( Client* client ){
  68. EQ2Packet* app = commands.GetRemoteCommands()->serialize();
  69. client->QueuePacket(app);
  70. }
  71. void ClientPacketFunctions::SendGameWorldTime ( Client* client ){
  72. PacketStruct* packet = world.GetWorldTime(client->GetVersion());
  73. if(packet){
  74. client->QueuePacket(packet->serialize());
  75. safe_delete(packet);
  76. }
  77. //opcode 501 was the selection display opcode
  78. }
  79. void ClientPacketFunctions::SendCharacterData ( Client* client ){
  80. client->GetPlayer()->SetCharacterID(client->GetCharacterID());
  81. EQ2Packet* outapp = client->GetPlayer()->serialize(client->GetPlayer(), client->GetVersion());
  82. //DumpPacket(outapp);
  83. client->QueuePacket(outapp);
  84. //client->GetPlayer()->ClearRemovedSpawn(client->GetPlayer());
  85. }
  86. void ClientPacketFunctions::SendCharacterSheet ( Client* client ){
  87. EQ2Packet* app = client->GetPlayer()->GetPlayerInfo()->serialize(client->GetVersion());
  88. client->QueuePacket(app);
  89. if (client->GetVersion() >= 1188) {
  90. EQ2Packet* app2 = client->GetPlayer()->GetPlayerInfo()->serializePet(client->GetVersion());
  91. if (app2)
  92. client->QueuePacket(app2);
  93. }
  94. }
  95. void ClientPacketFunctions::SendSkillBook ( Client* client ){
  96. EQ2Packet* app = client->GetPlayer()->skill_list.GetSkillPacket(client->GetVersion());
  97. if(app)
  98. client->QueuePacket(app);
  99. }
  100. // Jabantiz: Attempt to get the char trait list working
  101. void ClientPacketFunctions::SendTraitList ( Client* client ){
  102. EQ2Packet* traitApp = master_trait_list.GetTraitListPacket(client);
  103. //DumpPacket(traitApp);
  104. if (traitApp){
  105. client->QueuePacket(traitApp);
  106. }
  107. }
  108. void ClientPacketFunctions::SendClassAA( Client* client ){
  109. int16 version = 1;
  110. if(client)
  111. version = client->GetVersion();
  112. PacketStruct* packet = configReader.getStruct("WS_DisplayHouseStatus", version);
  113. packet->setDataByName("spawn_id", client->GetCharacterID());
  114. packet->setDataByName("house_name", client->GetPlayer()->GetName());
  115. packet->setDataByName("house_location", "Qeynos Village Inn");
  116. packet->PrintPacket();
  117. EQ2Packet* data = packet->serialize();
  118. EQ2Packet* app = new EQ2Packet(OP_PlayerHouseDisplayStatusMsg, data->pBuffer, data->size);
  119. safe_delete(packet);
  120. safe_delete(data);
  121. client->QueuePacket(app);
  122. }
  123. void ClientPacketFunctions::SendAbilities ( Client* client ){
  124. LogWrite(MISC__TODO, 1, "TODO", " Add SendAbilities functionality\n\t(%s, function: %s, line #: %i)", __FILE__, __FUNCTION__, __LINE__);
  125. // this is the featherfall ability data
  126. // later this would loop through and send all abilities
  127. /*uchar abilityData[] ={0x11,0x00,0x00,0x00,0xff,0x15,0x02,0x00,0x0b,0x00,0x46,0x65,0x61,0x74
  128. ,0x68,0x65,0x72,0x66,0x61,0x6c,0x6c};
  129. EQ2Packet* abilityApp = new EQ2Packet(OP_ClientCmdMsg, abilityData, sizeof(abilityData));
  130. client->QueuePacket(abilityApp);*/
  131. }
  132. void ClientPacketFunctions::SendCommandNamePacket ( Client* client ){
  133. LogWrite(MISC__TODO, 1, "TODO", " fix, this is actually quest/collection information\n\t(%s, function: %s, line #: %i)", __FILE__, __FUNCTION__, __LINE__);
  134. /*
  135. PacketStruct* command_packet = configReader.getStruct("WS_CommandName", client->GetVersion());
  136. if(command_packet){
  137. command_packet->setDataByName("unknown03", 0x221bfb47);
  138. char* charName = { "BogusName" };
  139. command_packet->setMediumStringByName("character_name",charName);
  140. EQ2Packet* outapp = command_packet->serialize();
  141. client->QueuePacket(outapp);
  142. safe_delete(command_packet);
  143. }
  144. */
  145. }
  146. void ClientPacketFunctions::SendQuickBarInit ( Client* client ){
  147. int32 count = database.LoadPlayerSkillbar(client);
  148. if(count == 0) {
  149. LogWrite(PACKET__DEBUG, 0, "Packet", "No character quickbar found!");
  150. database.UpdateStartingSkillbar(client->GetCharacterID(), client->GetPlayer()->GetAdventureClass(), client->GetPlayer()->GetRace());
  151. database.LoadPlayerSkillbar(client);
  152. }
  153. EQ2Packet* quickbarApp = client->GetPlayer()->GetQuickbarPacket(client->GetVersion());
  154. if(quickbarApp)
  155. client->QueuePacket(quickbarApp);
  156. }
  157. void ClientPacketFunctions::SendCharacterMacros(Client* client) {
  158. LogWrite(PACKET__DEBUG, 0, "Packet", "Sending Character Macro packet (WS_MacroInit, %i)", client->GetVersion());
  159. map<int8, vector<MacroData*> >* macros = database.LoadCharacterMacros(client->GetCharacterID());
  160. if(macros) {
  161. PacketStruct* macro_packet = configReader.getStruct("WS_MacroInit", client->GetVersion());
  162. if(macro_packet) {
  163. map<int8, vector<MacroData*> >::iterator itr;
  164. macro_packet->setArrayLengthByName("macro_count", macros->size());
  165. int8 x = 0;
  166. for(itr=macros->begin();itr!=macros->end();itr++, x++) {
  167. macro_packet->setArrayDataByName("number", itr->first, x);
  168. if(itr->second.size() > 0) {
  169. LogWrite(PACKET__DEBUG, 5, "Packet", "Loading Macro %i, name: %s", itr->first, itr->second[0]->name.c_str());
  170. macro_packet->setArrayDataByName("name", itr->second[0]->name.c_str(), x);
  171. }
  172. char tmp_details_count[25] = {0};
  173. sprintf(tmp_details_count, "macro_details_count_%i", x);
  174. macro_packet->setArrayLengthByName(tmp_details_count, itr->second.size());
  175. for(int8 i=0;i<itr->second.size();i++) {
  176. char tmp_command[15] = {0};
  177. sprintf(tmp_command, "command%i", x);
  178. LogWrite(PACKET__DEBUG, 5, "Packet", "\tLoading Command %i: %s", itr->first, x, itr->second[i]->text.c_str());
  179. macro_packet->setArrayDataByName(tmp_command, itr->second[i]->text.c_str(), i);
  180. }
  181. macro_packet->setArrayDataByName("unknown2", 2, x);
  182. macro_packet->setArrayDataByName("icon", itr->second[0]->icon, x);
  183. client->GetPlayer()->macro_icons[itr->first] = itr->second[0]->icon;
  184. macro_packet->setArrayDataByName("unknown3", 0xFFFFFFFF, x);
  185. }
  186. EQ2Packet* packet = macro_packet->serialize();
  187. client->QueuePacket(packet);
  188. safe_delete(macro_packet);
  189. }
  190. safe_delete(macros);
  191. }
  192. }
  193. void ClientPacketFunctions::SendMOTD ( Client* client ){
  194. const char* motd = 0;
  195. // fetch MOTD from `variables` table
  196. Variable* var = variables.FindVariable("motd");
  197. if( var == NULL || strlen (var->GetValue()) == 0) {
  198. LogWrite(WORLD__WARNING, 0, "World", "No MOTD set. Sending generic message...");
  199. client->SimpleMessage(CHANNEL_COLOR_YELLOW, "Message of the Day: Welcome to EQ2Emulator! Customize this message in the `variables`.`motd` data!");
  200. }
  201. else {
  202. motd = var->GetValue();
  203. LogWrite(WORLD__DEBUG, 0, "World", "Send MOTD...");
  204. client->SimpleMessage(CHANNEL_COLOR_YELLOW, motd);
  205. }
  206. }
  207. void ClientPacketFunctions::SendUpdateSpellBook ( Client* client ){
  208. EQ2Packet* app = client->GetPlayer()->GetSpellBookUpdatePacket(client->GetVersion());
  209. if(app)
  210. client->QueuePacket(app);
  211. client->GetPlayer()->UnlockAllSpells(true);
  212. }
  213. void ClientPacketFunctions::SendLoginCommandMessages ( Client* client ){
  214. LogWrite(MISC__TODO, 1, "TODO", "Why is this function empty? Func: %s", __FUNCTION__);
  215. }
  216. void ClientPacketFunctions::SendServerControlFlags(Client* client, int8 param, int8 param_val, int8 value) {
  217. PacketStruct* packet = configReader.getStruct("WS_ServerControlFlags", client->GetVersion());
  218. if(packet) {
  219. if (param == 1)
  220. packet->setDataByName("parameter1", param_val);
  221. else if (param == 2)
  222. packet->setDataByName("parameter2", param_val);
  223. else if (param == 3)
  224. packet->setDataByName("parameter3", param_val);
  225. else if (param == 4)
  226. packet->setDataByName("parameter4", param_val);
  227. else if (param == 5)
  228. packet->setDataByName("parameter5", param_val);
  229. else {
  230. safe_delete(packet);
  231. return;
  232. }
  233. packet->setDataByName("value", value);
  234. client->QueuePacket(packet->serialize());
  235. /*
  236. Some other values for this packet
  237. first param:
  238. 01 flymode
  239. 02 collisons off
  240. 04 unknown
  241. 08 heading movement only
  242. 16 forward/reverse movement only
  243. 32 low gravity
  244. 64 sit
  245. second
  246. 2 crouch
  247. third:
  248. 04 float when trying to jump, no movement
  249. 08 jump high, no movement
  250. 128 walk underwater
  251. fourth:
  252. 01 moon jump underwater
  253. 04 fear
  254. 16 moon jumps
  255. 32 safe fall (float to ground)
  256. 64 cant move
  257. fifth:
  258. 01 die
  259. 08 hover (fae)
  260. 32 flymode2?
  261. */
  262. }
  263. safe_delete(packet);
  264. }
  265. void ClientPacketFunctions::SendInstanceList(Client* client) {
  266. if (client->GetPlayer()->GetCharacterInstances()->GetInstanceCount() > 0) {
  267. PacketStruct* packet = configReader.getStruct("WS_InstanceCreated", client->GetVersion());
  268. if (packet) {
  269. vector<InstanceData> persist = client->GetPlayer()->GetCharacterInstances()->GetPersistentInstances();
  270. vector<InstanceData> lockout = client->GetPlayer()->GetCharacterInstances()->GetLockoutInstances();
  271. packet->setArrayLengthByName("num_instances", lockout.size());
  272. for (int32 i = 0; i < lockout.size(); i++) {
  273. InstanceData data = lockout.at(i);
  274. packet->setArrayDataByName("unknown1", data.db_id, i); // unique id per player
  275. packet->setArrayDataByName("instance_zone_name", data.zone_name.c_str(), i);
  276. packet->setArrayDataByName("unknown2", 0x0B, i); // Always set to 0x0B on live packets
  277. packet->setArrayDataByName("success_last", data.last_success_timestamp, i);
  278. packet->setArrayDataByName("last_failure", data.last_failure_timestamp, i);
  279. packet->setArrayDataByName("failure", data.failure_lockout_time, i);
  280. packet->setArrayDataByName("success", data.success_lockout_time, i);
  281. }
  282. packet->setArrayLengthByName("num_persistent", persist.size());
  283. for (int32 i = 0; i < persist.size(); i++) {
  284. InstanceData data = persist.at(i);
  285. packet->setArrayDataByName("unknown1a", data.db_id, i); // unique id per player
  286. packet->setArrayDataByName("persistent_zone_name", data.zone_name.c_str(), i);
  287. packet->setArrayDataByName("unknown2a", 0x0B, i); // set to 0x0B in all live packets
  288. packet->setArrayDataByName("persist_success_timestamp", data.last_success_timestamp, i);
  289. packet->setArrayDataByName("persist_failure_timestamp", data.last_failure_timestamp, i);
  290. // Check min duration (last success + failure)
  291. //if (Timer::GetUnixTimeStamp() < data.last_success_timestamp + data.failure_lockout_time*/)
  292. //packet->setArrayDataByName("unknown3b", 1, i);
  293. packet->setArrayDataByName("unknown3b", 1, i);
  294. packet->setArrayDataByName("minimum_duration", data.failure_lockout_time, i);
  295. packet->setArrayDataByName("maximum_duration", data.success_lockout_time, i);
  296. packet->setArrayDataByName("unknown4a", 1800, i); // All live logs have 0x0708
  297. }
  298. client->QueuePacket(packet->serialize());
  299. }
  300. safe_delete(packet);
  301. }
  302. }
  303. void ClientPacketFunctions::SendMaintainedExamineUpdate(Client* client, int8 slot_pos, int32 update_value, int8 update_type){
  304. if (!client)
  305. return;
  306. PacketStruct* packet = configReader.getStruct("WS_UpdateMaintainedExamine", client->GetVersion());
  307. if (packet){
  308. packet->setSubstructDataByName("info_header", "show_name", 1);
  309. packet->setSubstructDataByName("info_header", "packettype", 19710);
  310. packet->setSubstructDataByName("info_header", "packetsubtype", 5);
  311. packet->setDataByName("time_stamp", Timer::GetCurrentTime2());
  312. packet->setDataByName("slot_pos", slot_pos);
  313. packet->setDataByName("update_value", update_value > 0 ? update_value : 0xFFFFFFFF);
  314. packet->setDataByName("update_type", update_type);
  315. client->QueuePacket(packet->serialize());
  316. safe_delete(packet);
  317. }
  318. }
  319. void ClientPacketFunctions::SendZoneChange(Client* client, char* zone_ip, int16 zone_port, int32 key) {
  320. if (!client)
  321. return;
  322. PacketStruct* packet = configReader.getStruct("WS_ZoneChangeMsg", client->GetVersion());
  323. if (packet) {
  324. packet->setDataByName("account_id", client->GetAccountID());
  325. packet->setDataByName("key", key);
  326. packet->setDataByName("ip_address", zone_ip);
  327. packet->setDataByName("port", zone_port);
  328. client->QueuePacket(packet->serialize());
  329. }
  330. safe_delete(packet);
  331. }
  332. void ClientPacketFunctions::SendStateCommand(Client* client, int32 spawn_id, int32 state) {
  333. if (!client) {
  334. return;
  335. }
  336. PacketStruct* packet = configReader.getStruct("WS_StateCmd", client->GetVersion());
  337. if (packet) {
  338. packet->setDataByName("spawn_id", spawn_id);
  339. packet->setDataByName("state", state);
  340. client->QueuePacket(packet->serialize());
  341. }
  342. safe_delete(packet);
  343. }