minetest/src/network/packethandlers/client.cpp

1025 lines
26 KiB
C++
Raw Normal View History

[Patch 2/4] Network rework: packet writing, sending and cleanups NetworkPacket.cpp: * Remove some deprecated functions, we must use streaming interface * m_data converted from u8* to std::vector<u8> * Add an exporter to forge packet to Connection object * implement operator << std::wstring. n * implement operator << std::string * dynamic resize when write packet content. * fix string writing and performances. * create ServerCommandFactory, used by client to get useful informations about packet processing (sending). * Reliability * Transmit channel * Implement putRawString for some ugly char (_INIT packet), and use it. * Many packet read and write migrated * Implement oldForgePacket to interface writing with current connection * fix U8/char/bool writing * fix string writing and performances. * add some missing functions * Use v3s16 read instead of reading x,y,z separately * Add irr::video::SColor support into packets * Add some missing handlers * Add a template function to increase offset * Throw a serialization error on packet reading (must be improved) PacketFactories: * Create ServerCommandFactory, used by client to get useful informations about packet processing (sending). * Create ClientCommandFactory, used by server to get useful informations about packet processing (sending). Client.cpp: * implement NetworkPacket ::Send interface. * Move packet handlers to a dedicated file * Remove Client::Send(SharedBuffer) Server.cpp: * implement NetworkPacket ::Send interface. * Rewrite all packets using NetworkPacket * Move packet handlers to a dedicated file * Remove Server::Send(SharedBuffer) ClientIface.cpp: * Remove sendToAll(SharedBuffer<u8>) Connection.hpp rework: * Remove duplicate include * Remove duplicate negation * Remove a useless variable * Improve code performance by using a m_peers_list instead of scanning m_peers map * Remove Connection::Send(SharedBuffer) * Fix useafterfree into NetworkPacket Sending * Remove unused Connection::sendToAll Test.cpp: * Remove dead code * Update tests to use NetworkPackets Misc: * add new wrappers to Send packets in client, using NetworkPacket * Add NetworkPacket methods for Connection * coding style fix * dead code since changes cleanup * Use v3s16 read instead of reading x,y,z separately in some packets * Use different files to handle packets received by client and server * Cleanup: Remove useless includes ok @Zeno- Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 11:37:49 +01:00
/*
Minetest
Copyright (C) 2015 nerzhul, Loic Blot <loic.blot@unix-experience.fr>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "client.h"
2015-02-21 13:00:57 +01:00
#include "util/base64.h"
[Patch 2/4] Network rework: packet writing, sending and cleanups NetworkPacket.cpp: * Remove some deprecated functions, we must use streaming interface * m_data converted from u8* to std::vector<u8> * Add an exporter to forge packet to Connection object * implement operator << std::wstring. n * implement operator << std::string * dynamic resize when write packet content. * fix string writing and performances. * create ServerCommandFactory, used by client to get useful informations about packet processing (sending). * Reliability * Transmit channel * Implement putRawString for some ugly char (_INIT packet), and use it. * Many packet read and write migrated * Implement oldForgePacket to interface writing with current connection * fix U8/char/bool writing * fix string writing and performances. * add some missing functions * Use v3s16 read instead of reading x,y,z separately * Add irr::video::SColor support into packets * Add some missing handlers * Add a template function to increase offset * Throw a serialization error on packet reading (must be improved) PacketFactories: * Create ServerCommandFactory, used by client to get useful informations about packet processing (sending). * Create ClientCommandFactory, used by server to get useful informations about packet processing (sending). Client.cpp: * implement NetworkPacket ::Send interface. * Move packet handlers to a dedicated file * Remove Client::Send(SharedBuffer) Server.cpp: * implement NetworkPacket ::Send interface. * Rewrite all packets using NetworkPacket * Move packet handlers to a dedicated file * Remove Server::Send(SharedBuffer) ClientIface.cpp: * Remove sendToAll(SharedBuffer<u8>) Connection.hpp rework: * Remove duplicate include * Remove duplicate negation * Remove a useless variable * Improve code performance by using a m_peers_list instead of scanning m_peers map * Remove Connection::Send(SharedBuffer) * Fix useafterfree into NetworkPacket Sending * Remove unused Connection::sendToAll Test.cpp: * Remove dead code * Update tests to use NetworkPackets Misc: * add new wrappers to Send packets in client, using NetworkPacket * Add NetworkPacket methods for Connection * coding style fix * dead code since changes cleanup * Use v3s16 read instead of reading x,y,z separately in some packets * Use different files to handle packets received by client and server * Cleanup: Remove useless includes ok @Zeno- Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 11:37:49 +01:00
#include "clientmedia.h"
#include "log.h"
#include "map.h"
#include "mapsector.h"
#include "nodedef.h"
#include "serialization.h"
#include "server.h"
#include "strfnd.h"
#include "network/clientopcodes.h"
#include "util/serialize.h"
void Client::handleCommand_Deprecated(NetworkPacket* pkt)
{
infostream << "Got deprecated command "
<< toClientCommandTable[pkt->getCommand()].name << " from peer "
<< pkt->getPeerId() << "!" << std::endl;
}
void Client::handleCommand_Init(NetworkPacket* pkt)
{
if (pkt->getSize() < 1)
return;
u8 deployed;
*pkt >> deployed;
infostream << "Client: TOCLIENT_INIT received with "
"deployed=" << ((int)deployed & 0xff) << std::endl;
if (!ser_ver_supported(deployed)) {
infostream << "Client: TOCLIENT_INIT: Server sent "
<< "unsupported ser_fmt_ver"<< std::endl;
return;
}
m_server_ser_ver = deployed;
// Get player position
v3s16 playerpos_s16(0, BS * 2 + BS * 20, 0);
if (pkt->getSize() >= 1 + 6) {
*pkt >> playerpos_s16;
}
v3f playerpos_f = intToFloat(playerpos_s16, BS) - v3f(0, BS / 2, 0);
// Set player position
Player *player = m_env.getLocalPlayer();
assert(player != NULL);
player->setPosition(playerpos_f);
if (pkt->getSize() >= 1 + 6 + 8) {
// Get map seed
*pkt >> m_map_seed;
infostream << "Client: received map seed: " << m_map_seed << std::endl;
}
if (pkt->getSize() >= 1 + 6 + 8 + 4) {
*pkt >> m_recommended_send_interval;
infostream << "Client: received recommended send interval "
<< m_recommended_send_interval<<std::endl;
}
// Reply to server
NetworkPacket* resp_pkt = new NetworkPacket(TOSERVER_INIT2, 0);
Send(resp_pkt);
m_state = LC_Init;
}
void Client::handleCommand_AccessDenied(NetworkPacket* pkt)
{
// The server didn't like our password. Note, this needs
// to be processed even if the serialisation format has
// not been agreed yet, the same as TOCLIENT_INIT.
m_access_denied = true;
m_access_denied_reason = L"Unknown";
if (pkt->getSize() >= 2) {
*pkt >> m_access_denied_reason;
}
}
void Client::handleCommand_RemoveNode(NetworkPacket* pkt)
{
if (pkt->getSize() < 6)
return;
v3s16 p;
*pkt >> p;
removeNode(p);
}
void Client::handleCommand_AddNode(NetworkPacket* pkt)
{
if (pkt->getSize() < 6 + MapNode::serializedLength(m_server_ser_ver))
return;
v3s16 p;
*pkt >> p;
MapNode n;
n.deSerialize(pkt->getU8Ptr(6), m_server_ser_ver);
bool remove_metadata = true;
u32 index = 6 + MapNode::serializedLength(m_server_ser_ver);
if ((pkt->getSize() >= index + 1) && pkt->getU8(index)) {
remove_metadata = false;
}
addNode(p, n, remove_metadata);
}
void Client::handleCommand_BlockData(NetworkPacket* pkt)
{
// Ignore too small packet
if (pkt->getSize() < 6)
return;
v3s16 p;
*pkt >> p;
std::string datastring(pkt->getString(6), pkt->getSize() - 6);
std::istringstream istr(datastring, std::ios_base::binary);
MapSector *sector;
MapBlock *block;
v2s16 p2d(p.X, p.Z);
sector = m_env.getMap().emergeSector(p2d);
assert(sector->getPos() == p2d);
block = sector->getBlockNoCreateNoEx(p.Y);
if (block) {
/*
Update an existing block
*/
block->deSerialize(istr, m_server_ser_ver, false);
block->deSerializeNetworkSpecific(istr);
}
else {
/*
Create a new block
*/
block = new MapBlock(&m_env.getMap(), p, this);
block->deSerialize(istr, m_server_ser_ver, false);
block->deSerializeNetworkSpecific(istr);
sector->insertBlock(block);
}
if (localdb != NULL) {
((ServerMap&) localserver->getMap()).saveBlock(block, localdb);
}
/*
Add it to mesh update queue and set it to be acknowledged after update.
*/
addUpdateMeshTaskWithEdge(p, true);
}
void Client::handleCommand_Inventory(NetworkPacket* pkt)
{
if (pkt->getSize() < 1)
return;
std::string datastring(pkt->getString(0), pkt->getSize());
std::istringstream is(datastring, std::ios_base::binary);
Player *player = m_env.getLocalPlayer();
assert(player != NULL);
player->inventory.deSerialize(is);
m_inventory_updated = true;
delete m_inventory_from_server;
m_inventory_from_server = new Inventory(player->inventory);
m_inventory_from_server_age = 0.0;
}
void Client::handleCommand_TimeOfDay(NetworkPacket* pkt)
{
if (pkt->getSize() < 2)
return;
u16 time_of_day;
*pkt >> time_of_day;
time_of_day = time_of_day % 24000;
float time_speed = 0;
if (pkt->getSize() >= 2 + 4) {
*pkt >> time_speed;
}
else {
// Old message; try to approximate speed of time by ourselves
float time_of_day_f = (float)time_of_day / 24000.0;
float tod_diff_f = 0;
if (time_of_day_f < 0.2 && m_last_time_of_day_f > 0.8)
tod_diff_f = time_of_day_f - m_last_time_of_day_f + 1.0;
else
tod_diff_f = time_of_day_f - m_last_time_of_day_f;
m_last_time_of_day_f = time_of_day_f;
float time_diff = m_time_of_day_update_timer;
m_time_of_day_update_timer = 0;
if (m_time_of_day_set) {
time_speed = (3600.0 * 24.0) * tod_diff_f / time_diff;
infostream << "Client: Measured time_of_day speed (old format): "
<< time_speed << " tod_diff_f=" << tod_diff_f
<< " time_diff=" << time_diff << std::endl;
}
}
// Update environment
m_env.setTimeOfDay(time_of_day);
m_env.setTimeOfDaySpeed(time_speed);
m_time_of_day_set = true;
u32 dr = m_env.getDayNightRatio();
infostream << "Client: time_of_day=" << time_of_day
<< " time_speed=" << time_speed
<< " dr=" << dr << std::endl;
}
void Client::handleCommand_ChatMessage(NetworkPacket* pkt)
{
/*
u16 command
u16 length
wstring message
*/
u16 len, read_wchar;
*pkt >> len;
std::wstring message;
for (u32 i = 0; i < len; i++) {
*pkt >> read_wchar;
message += (wchar_t)read_wchar;
}
m_chat_queue.push_back(message);
}
void Client::handleCommand_ActiveObjectRemoveAdd(NetworkPacket* pkt)
{
/*
u16 command
u16 count of removed objects
for all removed objects {
u16 id
}
u16 count of added objects
for all added objects {
u16 id
u8 type
u32 initialization data length
string initialization data
}
*/
// Read removed objects
u8 type;
u16 removed_count, added_count, id;
*pkt >> removed_count;
for (u16 i = 0; i < removed_count; i++) {
*pkt >> id;
m_env.removeActiveObject(id);
}
// Read added objects
*pkt >> added_count;
for (u16 i = 0; i < added_count; i++) {
*pkt >> id >> type;
m_env.addActiveObject(id, type, pkt->readLongString());
}
}
void Client::handleCommand_ActiveObjectMessages(NetworkPacket* pkt)
{
/*
u16 command
for all objects
{
u16 id
u16 message length
string message
}
*/
char buf[6];
// Get all data except the command number
std::string datastring(pkt->getString(0), pkt->getSize());
// Throw them in an istringstream
std::istringstream is(datastring, std::ios_base::binary);
while(is.eof() == false) {
is.read(buf, 2);
u16 id = readU16((u8*)buf);
if (is.eof())
break;
is.read(buf, 2);
size_t message_size = readU16((u8*)buf);
std::string message;
message.reserve(message_size);
for (u32 i = 0; i < message_size; i++) {
is.read(buf, 1);
message.append(buf, 1);
}
// Pass on to the environment
m_env.processActiveObjectMessage(id, message);
}
}
void Client::handleCommand_Movement(NetworkPacket* pkt)
{
Player *player = m_env.getLocalPlayer();
assert(player != NULL);
float mad, maa, maf, msw, mscr, msf, mscl, msj, lf, lfs, ls, g;
*pkt >> mad >> maa >> maf >> msw >> mscr >> msf >> mscl >> msj
>> lf >> lfs >> ls >> g;
player->movement_acceleration_default = mad * BS;
player->movement_acceleration_air = maa * BS;
player->movement_acceleration_fast = maf * BS;
player->movement_speed_walk = msw * BS;
player->movement_speed_crouch = mscr * BS;
player->movement_speed_fast = msf * BS;
player->movement_speed_climb = mscl * BS;
player->movement_speed_jump = msj * BS;
player->movement_liquid_fluidity = lf * BS;
player->movement_liquid_fluidity_smooth = lfs * BS;
player->movement_liquid_sink = ls * BS;
player->movement_gravity = g * BS;
}
void Client::handleCommand_HP(NetworkPacket* pkt)
{
Player *player = m_env.getLocalPlayer();
assert(player != NULL);
u8 oldhp = player->hp;
u8 hp;
*pkt >> hp;
player->hp = hp;
if (hp < oldhp) {
// Add to ClientEvent queue
ClientEvent event;
event.type = CE_PLAYER_DAMAGE;
event.player_damage.amount = oldhp - hp;
m_client_event_queue.push_back(event);
}
}
void Client::handleCommand_Breath(NetworkPacket* pkt)
{
Player *player = m_env.getLocalPlayer();
assert(player != NULL);
u16 breath;
*pkt >> breath;
player->setBreath(breath);
}
void Client::handleCommand_MovePlayer(NetworkPacket* pkt)
{
Player *player = m_env.getLocalPlayer();
assert(player != NULL);
v3f pos;
f32 pitch, yaw;
*pkt >> pos >> pitch >> yaw;
player->setPosition(pos);
infostream << "Client got TOCLIENT_MOVE_PLAYER"
<< " pos=(" << pos.X << "," << pos.Y << "," << pos.Z << ")"
<< " pitch=" << pitch
<< " yaw=" << yaw
<< std::endl;
/*
Add to ClientEvent queue.
This has to be sent to the main program because otherwise
it would just force the pitch and yaw values to whatever
the camera points to.
*/
ClientEvent event;
event.type = CE_PLAYER_FORCE_MOVE;
event.player_force_move.pitch = pitch;
event.player_force_move.yaw = yaw;
m_client_event_queue.push_back(event);
// Ignore damage for a few seconds, so that the player doesn't
// get damage from falling on ground
m_ignore_damage_timer = 3.0;
}
void Client::handleCommand_PlayerItem(NetworkPacket* pkt)
{
infostream << "Client: WARNING: Ignoring TOCLIENT_PLAYERITEM" << std::endl;
}
void Client::handleCommand_DeathScreen(NetworkPacket* pkt)
{
bool set_camera_point_target;
v3f camera_point_target;
*pkt >> set_camera_point_target;
*pkt >> camera_point_target;
ClientEvent event;
event.type = CE_DEATHSCREEN;
event.deathscreen.set_camera_point_target = set_camera_point_target;
event.deathscreen.camera_point_target_x = camera_point_target.X;
event.deathscreen.camera_point_target_y = camera_point_target.Y;
event.deathscreen.camera_point_target_z = camera_point_target.Z;
m_client_event_queue.push_back(event);
}
void Client::handleCommand_AnnounceMedia(NetworkPacket* pkt)
{
u16 num_files;
*pkt >> num_files;
infostream << "Client: Received media announcement: packet size: "
<< pkt->getSize() << std::endl;
if (m_media_downloader == NULL ||
m_media_downloader->isStarted()) {
const char *problem = m_media_downloader ?
"we already saw another announcement" :
"all media has been received already";
errorstream << "Client: Received media announcement but "
<< problem << "! "
<< " files=" << num_files
<< " size=" << pkt->getSize() << std::endl;
return;
}
// Mesh update thread must be stopped while
// updating content definitions
assert(!m_mesh_update_thread.IsRunning());
for (u16 i = 0; i < num_files; i++) {
std::string name, sha1_base64;
*pkt >> name >> sha1_base64;
std::string sha1_raw = base64_decode(sha1_base64);
m_media_downloader->addFile(name, sha1_raw);
}
std::vector<std::string> remote_media;
try {
std::string str;
*pkt >> str;
Strfnd sf(str);
while(!sf.atend()) {
std::string baseurl = trim(sf.next(","));
if (baseurl != "")
m_media_downloader->addRemoteServer(baseurl);
}
}
catch(SerializationError& e) {
// not supported by server or turned off
}
m_media_downloader->step(this);
}
void Client::handleCommand_Media(NetworkPacket* pkt)
{
/*
u16 command
u16 total number of file bunches
u16 index of this bunch
u32 number of files in this bunch
for each file {
u16 length of name
string name
u32 length of data
data
}
*/
u16 num_bunches;
u16 bunch_i;
u32 num_files;
*pkt >> num_bunches >> bunch_i >> num_files;
infostream << "Client: Received files: bunch " << bunch_i << "/"
<< num_bunches << " files=" << num_files
<< " size=" << pkt->getSize() << std::endl;
if (num_files == 0)
return;
if (m_media_downloader == NULL ||
!m_media_downloader->isStarted()) {
const char *problem = m_media_downloader ?
"media has not been requested" :
"all media has been received already";
errorstream << "Client: Received media but "
<< problem << "! "
<< " bunch " << bunch_i << "/" << num_bunches
<< " files=" << num_files
<< " size=" << pkt->getSize() << std::endl;
return;
}
// Mesh update thread must be stopped while
// updating content definitions
assert(!m_mesh_update_thread.IsRunning());
for (u32 i=0; i < num_files; i++) {
std::string name;
*pkt >> name;
std::string data = pkt->readLongString();
m_media_downloader->conventionalTransferDone(
name, data, this);
}
}
void Client::handleCommand_ToolDef(NetworkPacket* pkt)
{
infostream << "Client: WARNING: Ignoring TOCLIENT_TOOLDEF" << std::endl;
}
void Client::handleCommand_NodeDef(NetworkPacket* pkt)
{
infostream << "Client: Received node definitions: packet size: "
<< pkt->getSize() << std::endl;
// Mesh update thread must be stopped while
// updating content definitions
assert(!m_mesh_update_thread.IsRunning());
// Decompress node definitions
std::string datastring(pkt->getString(0), pkt->getSize());
std::istringstream is(datastring, std::ios_base::binary);
std::istringstream tmp_is(deSerializeLongString(is), std::ios::binary);
std::ostringstream tmp_os;
decompressZlib(tmp_is, tmp_os);
// Deserialize node definitions
std::istringstream tmp_is2(tmp_os.str());
m_nodedef->deSerialize(tmp_is2);
m_nodedef_received = true;
}
void Client::handleCommand_CraftItemDef(NetworkPacket* pkt)
{
infostream << "Client: WARNING: Ignoring TOCLIENT_CRAFTITEMDEF" << std::endl;
}
void Client::handleCommand_ItemDef(NetworkPacket* pkt)
{
infostream << "Client: Received item definitions: packet size: "
<< pkt->getSize() << std::endl;
// Mesh update thread must be stopped while
// updating content definitions
assert(!m_mesh_update_thread.IsRunning());
// Decompress item definitions
std::string datastring(pkt->getString(0), pkt->getSize());
std::istringstream is(datastring, std::ios_base::binary);
std::istringstream tmp_is(deSerializeLongString(is), std::ios::binary);
std::ostringstream tmp_os;
decompressZlib(tmp_is, tmp_os);
// Deserialize node definitions
std::istringstream tmp_is2(tmp_os.str());
m_itemdef->deSerialize(tmp_is2);
m_itemdef_received = true;
}
void Client::handleCommand_PlaySound(NetworkPacket* pkt)
{
s32 server_id;
std::string name;
float gain;
u8 type; // 0=local, 1=positional, 2=object
v3f pos;
u16 object_id;
bool loop;
*pkt >> server_id >> name >> gain >> type >> pos >> object_id >> loop;
// Start playing
int client_id = -1;
switch(type) {
case 0: // local
client_id = m_sound->playSound(name, loop, gain);
break;
case 1: // positional
client_id = m_sound->playSoundAt(name, loop, gain, pos);
break;
case 2:
{ // object
ClientActiveObject *cao = m_env.getActiveObject(object_id);
if (cao)
pos = cao->getPosition();
client_id = m_sound->playSoundAt(name, loop, gain, pos);
// TODO: Set up sound to move with object
break;
}
default:
break;
}
if (client_id != -1) {
m_sounds_server_to_client[server_id] = client_id;
m_sounds_client_to_server[client_id] = server_id;
if (object_id != 0)
m_sounds_to_objects[client_id] = object_id;
}
}
void Client::handleCommand_StopSound(NetworkPacket* pkt)
{
s32 server_id;
*pkt >> server_id;
std::map<s32, int>::iterator i =
m_sounds_server_to_client.find(server_id);
if (i != m_sounds_server_to_client.end()) {
int client_id = i->second;
m_sound->stopSound(client_id);
}
}
void Client::handleCommand_Privileges(NetworkPacket* pkt)
{
m_privileges.clear();
infostream << "Client: Privileges updated: ";
u16 num_privileges;
*pkt >> num_privileges;
for (u16 i = 0; i < num_privileges; i++) {
std::string priv;
*pkt >> priv;
m_privileges.insert(priv);
infostream << priv << " ";
}
infostream << std::endl;
}
void Client::handleCommand_InventoryFormSpec(NetworkPacket* pkt)
{
Player *player = m_env.getLocalPlayer();
assert(player != NULL);
// Store formspec in LocalPlayer
player->inventory_formspec = pkt->readLongString();
}
void Client::handleCommand_DetachedInventory(NetworkPacket* pkt)
{
std::string datastring(pkt->getString(0), pkt->getSize());
std::istringstream is(datastring, std::ios_base::binary);
std::string name = deSerializeString(is);
infostream << "Client: Detached inventory update: \"" << name
<< "\"" << std::endl;
Inventory *inv = NULL;
if (m_detached_inventories.count(name) > 0)
inv = m_detached_inventories[name];
else {
inv = new Inventory(m_itemdef);
m_detached_inventories[name] = inv;
}
inv->deSerialize(is);
}
void Client::handleCommand_ShowFormSpec(NetworkPacket* pkt)
{
std::string formspec = pkt->readLongString();
std::string formname;
*pkt >> formname;
ClientEvent event;
event.type = CE_SHOW_FORMSPEC;
// pointer is required as event is a struct only!
// adding a std:string to a struct isn't possible
event.show_formspec.formspec = new std::string(formspec);
event.show_formspec.formname = new std::string(formname);
m_client_event_queue.push_back(event);
}
void Client::handleCommand_SpawnParticle(NetworkPacket* pkt)
{
std::string datastring(pkt->getString(0), pkt->getSize());
std::istringstream is(datastring, std::ios_base::binary);
v3f pos = readV3F1000(is);
v3f vel = readV3F1000(is);
v3f acc = readV3F1000(is);
float expirationtime = readF1000(is);
float size = readF1000(is);
bool collisiondetection = readU8(is);
std::string texture = deSerializeLongString(is);
bool vertical = false;
try {
vertical = readU8(is);
} catch (...) {}
ClientEvent event;
event.type = CE_SPAWN_PARTICLE;
event.spawn_particle.pos = new v3f (pos);
event.spawn_particle.vel = new v3f (vel);
event.spawn_particle.acc = new v3f (acc);
event.spawn_particle.expirationtime = expirationtime;
event.spawn_particle.size = size;
event.spawn_particle.collisiondetection = collisiondetection;
event.spawn_particle.vertical = vertical;
event.spawn_particle.texture = new std::string(texture);
m_client_event_queue.push_back(event);
}
void Client::handleCommand_AddParticleSpawner(NetworkPacket* pkt)
{
u16 amount;
float spawntime;
v3f minpos;
v3f maxpos;
v3f minvel;
v3f maxvel;
v3f minacc;
v3f maxacc;
float minexptime;
float maxexptime;
float minsize;
float maxsize;
bool collisiondetection;
u32 id;
*pkt >> amount >> spawntime >> minpos >> maxpos >> minvel >> maxvel
>> minacc >> maxacc >> minexptime >> maxexptime >> minsize
>> maxsize >> collisiondetection;
std::string texture = pkt->readLongString();
*pkt >> id;
bool vertical = false;
try {
*pkt >> vertical;
} catch (...) {}
ClientEvent event;
event.type = CE_ADD_PARTICLESPAWNER;
event.add_particlespawner.amount = amount;
event.add_particlespawner.spawntime = spawntime;
event.add_particlespawner.minpos = new v3f (minpos);
event.add_particlespawner.maxpos = new v3f (maxpos);
event.add_particlespawner.minvel = new v3f (minvel);
event.add_particlespawner.maxvel = new v3f (maxvel);
event.add_particlespawner.minacc = new v3f (minacc);
event.add_particlespawner.maxacc = new v3f (maxacc);
event.add_particlespawner.minexptime = minexptime;
event.add_particlespawner.maxexptime = maxexptime;
event.add_particlespawner.minsize = minsize;
event.add_particlespawner.maxsize = maxsize;
event.add_particlespawner.collisiondetection = collisiondetection;
event.add_particlespawner.vertical = vertical;
event.add_particlespawner.texture = new std::string(texture);
event.add_particlespawner.id = id;
m_client_event_queue.push_back(event);
}
void Client::handleCommand_DeleteParticleSpawner(NetworkPacket* pkt)
{
u16 id;
*pkt >> id;
ClientEvent event;
event.type = CE_DELETE_PARTICLESPAWNER;
event.delete_particlespawner.id = (u32) id;
m_client_event_queue.push_back(event);
}
void Client::handleCommand_HudAdd(NetworkPacket* pkt)
{
std::string datastring(pkt->getString(0), pkt->getSize());
std::istringstream is(datastring, std::ios_base::binary);
u32 id;
u8 type;
v2f pos;
std::string name;
v2f scale;
std::string text;
u32 number;
u32 item;
u32 dir;
v2f align;
v2f offset;
v3f world_pos;
v2s32 size;
*pkt >> id >> type >> pos >> name >> scale >> text >> number >> item
>> dir >> align >> offset;
try {
*pkt >> world_pos;
}
catch(SerializationError &e) {};
try {
*pkt >> size;
} catch(SerializationError &e) {};
ClientEvent event;
event.type = CE_HUDADD;
event.hudadd.id = id;
event.hudadd.type = type;
event.hudadd.pos = new v2f(pos);
event.hudadd.name = new std::string(name);
event.hudadd.scale = new v2f(scale);
event.hudadd.text = new std::string(text);
event.hudadd.number = number;
event.hudadd.item = item;
event.hudadd.dir = dir;
event.hudadd.align = new v2f(align);
event.hudadd.offset = new v2f(offset);
event.hudadd.world_pos = new v3f(world_pos);
event.hudadd.size = new v2s32(size);
m_client_event_queue.push_back(event);
}
void Client::handleCommand_HudRemove(NetworkPacket* pkt)
{
u32 id;
*pkt >> id;
ClientEvent event;
event.type = CE_HUDRM;
event.hudrm.id = id;
m_client_event_queue.push_back(event);
}
void Client::handleCommand_HudChange(NetworkPacket* pkt)
{
std::string sdata;
v2f v2fdata;
v3f v3fdata;
u32 intdata = 0;
v2s32 v2s32data;
u32 id;
u8 stat;
*pkt >> id >> stat;
if (stat == HUD_STAT_POS || stat == HUD_STAT_SCALE ||
stat == HUD_STAT_ALIGN || stat == HUD_STAT_OFFSET)
*pkt >> v2fdata;
else if (stat == HUD_STAT_NAME || stat == HUD_STAT_TEXT)
*pkt >> sdata;
else if (stat == HUD_STAT_WORLD_POS)
*pkt >> v3fdata;
else if (stat == HUD_STAT_SIZE )
*pkt >> v2s32data;
else
*pkt >> intdata;
ClientEvent event;
event.type = CE_HUDCHANGE;
event.hudchange.id = id;
event.hudchange.stat = (HudElementStat)stat;
event.hudchange.v2fdata = new v2f(v2fdata);
event.hudchange.v3fdata = new v3f(v3fdata);
event.hudchange.sdata = new std::string(sdata);
event.hudchange.data = intdata;
event.hudchange.v2s32data = new v2s32(v2s32data);
m_client_event_queue.push_back(event);
}
void Client::handleCommand_HudSetFlags(NetworkPacket* pkt)
{
u32 flags, mask;
*pkt >> flags >> mask;
Player *player = m_env.getLocalPlayer();
assert(player != NULL);
player->hud_flags &= ~mask;
player->hud_flags |= flags;
}
void Client::handleCommand_HudSetParam(NetworkPacket* pkt)
{
u16 param; std::string value;
*pkt >> param >> value;
Player *player = m_env.getLocalPlayer();
assert(player != NULL);
if (param == HUD_PARAM_HOTBAR_ITEMCOUNT && value.size() == 4) {
s32 hotbar_itemcount = readS32((u8*) value.c_str());
if (hotbar_itemcount > 0 && hotbar_itemcount <= HUD_HOTBAR_ITEMCOUNT_MAX)
player->hud_hotbar_itemcount = hotbar_itemcount;
}
else if (param == HUD_PARAM_HOTBAR_IMAGE) {
((LocalPlayer *) player)->hotbar_image = value;
}
else if (param == HUD_PARAM_HOTBAR_SELECTED_IMAGE) {
((LocalPlayer *) player)->hotbar_selected_image = value;
}
}
void Client::handleCommand_HudSetSky(NetworkPacket* pkt)
{
std::string datastring(pkt->getString(0), pkt->getSize());
std::istringstream is(datastring, std::ios_base::binary);
video::SColor *bgcolor = new video::SColor(readARGB8(is));
std::string *type = new std::string(deSerializeString(is));
u16 count = readU16(is);
std::vector<std::string> *params = new std::vector<std::string>;
for (size_t i = 0; i < count; i++)
params->push_back(deSerializeString(is));
ClientEvent event;
event.type = CE_SET_SKY;
event.set_sky.bgcolor = bgcolor;
event.set_sky.type = type;
event.set_sky.params = params;
m_client_event_queue.push_back(event);
}
void Client::handleCommand_OverrideDayNightRatio(NetworkPacket* pkt)
{
bool do_override;
u16 day_night_ratio_u;
*pkt >> do_override >> day_night_ratio_u;
float day_night_ratio_f = (float)day_night_ratio_u / 65536;
ClientEvent event;
event.type = CE_OVERRIDE_DAY_NIGHT_RATIO;
event.override_day_night_ratio.do_override = do_override;
event.override_day_night_ratio.ratio_f = day_night_ratio_f;
m_client_event_queue.push_back(event);
}
void Client::handleCommand_LocalPlayerAnimations(NetworkPacket* pkt)
{
LocalPlayer *player = m_env.getLocalPlayer();
assert(player != NULL);
*pkt >> player->local_animations[0];
*pkt >> player->local_animations[1];
*pkt >> player->local_animations[2];
*pkt >> player->local_animations[3];
*pkt >> player->local_animation_speed;
}
void Client::handleCommand_EyeOffset(NetworkPacket* pkt)
{
LocalPlayer *player = m_env.getLocalPlayer();
assert(player != NULL);
*pkt >> player->eye_offset_first >> player->eye_offset_third;
}