#include "client.h"
#include "util/base64.h"
+#include "chatmessage.h"
#include "clientmedia.h"
#include "log.h"
#include "map.h"
#include "mapsector.h"
#include "minimap.h"
+#include "modchannels.h"
#include "nodedef.h"
#include "serialization.h"
#include "server.h"
#include "util/strfnd.h"
+#include "client/clientevent.h"
#include "network/clientopcodes.h"
+#include "network/connection.h"
#include "script/scripting_client.h"
#include "util/serialize.h"
#include "util/srp.h"
#include "tileanimation.h"
+#include "gettext.h"
void Client::handleCommand_Deprecated(NetworkPacket* pkt)
{
// we recieved a TOCLIENT_HELLO while auth was already going on
errorstream << "Client: TOCLIENT_HELLO while auth was already going on"
<< "(chosen_mech=" << m_chosen_auth_mech << ")." << std::endl;
- if ((m_chosen_auth_mech == AUTH_MECHANISM_SRP)
- || (m_chosen_auth_mech == AUTH_MECHANISM_LEGACY_PASSWORD)) {
+ if (m_chosen_auth_mech == AUTH_MECHANISM_SRP ||
+ m_chosen_auth_mech == AUTH_MECHANISM_LEGACY_PASSWORD) {
srp_user_delete((SRPUser *) m_auth_data);
m_auth_data = 0;
}
m_chosen_auth_mech = AUTH_MECHANISM_NONE;
m_access_denied = true;
m_access_denied_reason = "Unknown";
- m_con.Disconnect();
+ m_con->Disconnect();
}
}
<< m_recommended_send_interval<<std::endl;
// Reply to server
- NetworkPacket resp_pkt(TOSERVER_INIT2, 0);
+ std::string lang = gettext("LANG_CODE");
+ if (lang == "LANG_CODE")
+ lang = "";
+
+ NetworkPacket resp_pkt(TOSERVER_INIT2, sizeof(u16) + lang.size());
+ resp_pkt << lang;
Send(&resp_pkt);
m_state = LC_Init;
}
void Client::handleCommand_DenySudoMode(NetworkPacket* pkt)
{
- pushToChatQueue(L"Password change denied. Password NOT changed.");
+ ChatMessage *chatMessage = new ChatMessage(CHATMESSAGE_TYPE_SYSTEM,
+ L"Password change denied. Password NOT changed.");
+ pushToChatQueue(chatMessage);
// reset everything and be sad
deleteAuthData();
}
-void Client::handleCommand_InitLegacy(NetworkPacket* pkt)
-{
- if (pkt->getSize() < 1)
- return;
-
- u8 server_ser_ver;
- *pkt >> server_ser_ver;
-
- infostream << "Client: TOCLIENT_INIT_LEGACY received with "
- "server_ser_ver=" << ((int)server_ser_ver & 0xff) << std::endl;
-
- if (!ser_ver_supported(server_ser_ver)) {
- infostream << "Client: TOCLIENT_INIT_LEGACY: Server sent "
- << "unsupported ser_fmt_ver"<< std::endl;
- return;
- }
-
- m_server_ser_ver = server_ser_ver;
-
- // We can be totally wrong with this guess
- // but we only need some value < 25.
- m_proto_ver = 24;
-
- // 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
- LocalPlayer *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(TOSERVER_INIT2, 0);
- Send(&resp_pkt);
-
- m_state = LC_Init;
-}
void Client::handleCommand_AccessDenied(NetworkPacket* pkt)
{
m_access_denied = true;
m_access_denied_reason = "Unknown";
- if (pkt->getCommand() == TOCLIENT_ACCESS_DENIED) {
- if (pkt->getSize() < 1)
- return;
-
- u8 denyCode = SERVER_ACCESSDENIED_UNEXPECTED_DATA;
- *pkt >> denyCode;
- if (denyCode == SERVER_ACCESSDENIED_SHUTDOWN ||
- denyCode == SERVER_ACCESSDENIED_CRASH) {
- *pkt >> m_access_denied_reason;
- if (m_access_denied_reason == "") {
- m_access_denied_reason = accessDeniedStrings[denyCode];
- }
- u8 reconnect;
- *pkt >> reconnect;
- m_access_denied_reconnect = reconnect & 1;
- } else if (denyCode == SERVER_ACCESSDENIED_CUSTOM_STRING) {
- *pkt >> m_access_denied_reason;
- } else if (denyCode < SERVER_ACCESSDENIED_MAX) {
- m_access_denied_reason = accessDeniedStrings[denyCode];
- } else {
- // Allow us to add new error messages to the
- // protocol without raising the protocol version, if we want to.
- // Until then (which may be never), this is outside
- // of the defined protocol.
- *pkt >> m_access_denied_reason;
- if (m_access_denied_reason == "") {
- m_access_denied_reason = "Unknown";
- }
- }
- }
- // 13/03/15 Legacy code from 0.4.12 and lesser. must stay 1 year
- // for compat with old clients
- else {
+ if (pkt->getCommand() != TOCLIENT_ACCESS_DENIED) {
+ // 13/03/15 Legacy code from 0.4.12 and lesser but is still used
+ // in some places of the server code
if (pkt->getSize() >= 2) {
std::wstring wide_reason;
*pkt >> wide_reason;
m_access_denied_reason = wide_to_utf8(wide_reason);
}
+ return;
+ }
+
+ if (pkt->getSize() < 1)
+ return;
+
+ u8 denyCode = SERVER_ACCESSDENIED_UNEXPECTED_DATA;
+ *pkt >> denyCode;
+ if (denyCode == SERVER_ACCESSDENIED_SHUTDOWN ||
+ denyCode == SERVER_ACCESSDENIED_CRASH) {
+ *pkt >> m_access_denied_reason;
+ if (m_access_denied_reason.empty()) {
+ m_access_denied_reason = accessDeniedStrings[denyCode];
+ }
+ u8 reconnect;
+ *pkt >> reconnect;
+ m_access_denied_reconnect = reconnect & 1;
+ } else if (denyCode == SERVER_ACCESSDENIED_CUSTOM_STRING) {
+ *pkt >> m_access_denied_reason;
+ } else if (denyCode < SERVER_ACCESSDENIED_MAX) {
+ m_access_denied_reason = accessDeniedStrings[denyCode];
+ } else {
+ // Allow us to add new error messages to the
+ // protocol without raising the protocol version, if we want to.
+ // Until then (which may be never), this is outside
+ // of the defined protocol.
+ *pkt >> m_access_denied_reason;
+ if (m_access_denied_reason.empty()) {
+ m_access_denied_reason = "Unknown";
+ }
}
}
}
else {
// Old message; try to approximate speed of time by ourselves
- float time_of_day_f = (float)time_of_day / 24000.0;
+ float time_of_day_f = (float)time_of_day / 24000.0f;
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;
+ tod_diff_f = time_of_day_f - m_last_time_of_day_f + 1.0f;
else
tod_diff_f = time_of_day_f - m_last_time_of_day_f;
m_time_of_day_update_timer = 0;
if (m_time_of_day_set) {
- time_speed = (3600.0 * 24.0) * tod_diff_f / time_diff;
+ time_speed = (3600.0f * 24.0f) * 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;
<< " dr=" << dr << std::endl;
}
-void Client::handleCommand_ChatMessage(NetworkPacket* pkt)
+void Client::handleCommand_ChatMessageOld(NetworkPacket *pkt)
{
/*
u16 command
}
// If chat message not consummed by client lua API
+ // @TODO send this to CSM using ChatMessage object
if (!moddingEnabled() || !m_script->on_receiving_message(wide_to_utf8(message))) {
- pushToChatQueue(message);
+ pushToChatQueue(new ChatMessage(message));
+ }
+}
+
+void Client::handleCommand_ChatMessage(NetworkPacket *pkt)
+{
+ /*
+ u8 version
+ u8 message_type
+ u16 sendername length
+ wstring sendername
+ u16 length
+ wstring message
+ */
+
+ ChatMessage *chatMessage = new ChatMessage();
+ u8 version, message_type;
+ *pkt >> version >> message_type;
+
+ if (version != 1 || message_type >= CHATMESSAGE_TYPE_MAX) {
+ delete chatMessage;
+ return;
+ }
+
+ *pkt >> chatMessage->sender >> chatMessage->message >> chatMessage->timestamp;
+
+ chatMessage->type = (ChatMessageType) message_type;
+
+ // @TODO send this to CSM using ChatMessage object
+ if (!moddingEnabled() || !m_script->on_receiving_message(
+ wide_to_utf8(chatMessage->message))) {
+ pushToChatQueue(chatMessage);
+ } else {
+ // Message was consumed by CSM and should not handled by client, destroying
+ delete chatMessage;
}
}
LocalPlayer *player = m_env.getLocalPlayer();
assert(player != NULL);
- u8 oldhp = player->hp;
+ u16 oldhp = player->hp;
- u8 hp;
+ u16 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;
+ ClientEvent *event = new ClientEvent();
+ event->type = CE_PLAYER_DAMAGE;
+ event->player_damage.amount = oldhp - hp;
m_client_event_queue.push(event);
}
}
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;
+ ClientEvent *event = new ClientEvent();
+ event->type = CE_PLAYER_FORCE_MOVE;
+ event->player_force_move.pitch = pitch;
+ event->player_force_move.yaw = yaw;
m_client_event_queue.push(event);
// Ignore damage for a few seconds, so that the player doesn't
*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;
+ ClientEvent *event = new ClientEvent();
+ 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(event);
}
Strfnd sf(str);
while(!sf.at_end()) {
std::string baseurl = trim(sf.next(","));
- if (baseurl != "")
+ if (!baseurl.empty())
m_media_downloader->addRemoteServer(baseurl);
}
}
if (num_files == 0)
return;
- if (m_media_downloader == NULL ||
- !m_media_downloader->isStarted()) {
+ if (!m_media_downloader || !m_media_downloader->isStarted()) {
const char *problem = m_media_downloader ?
"media has not been requested" :
"all media has been received already";
[23 + len] u16 object_id
[25 + len] bool loop
[26 + len] f32 fade
+ [30 + len] f32 pitch
*/
s32 server_id;
v3f pos;
u16 object_id;
bool loop;
- float fade = 0;
+ float fade = 0.0f;
+ float pitch = 1.0f;
*pkt >> server_id >> name >> gain >> type >> pos >> object_id >> loop;
try {
*pkt >> fade;
- } catch (SerializationError &e) {};
+ *pkt >> pitch;
+ } catch (PacketError &e) {};
// Start playing
int client_id = -1;
switch(type) {
case 0: // local
- client_id = m_sound->playSound(name, loop, gain, fade);
+ client_id = m_sound->playSound(name, loop, gain, fade, pitch);
break;
case 1: // positional
- client_id = m_sound->playSoundAt(name, loop, gain, pos);
+ client_id = m_sound->playSoundAt(name, loop, gain, pos, pitch);
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);
+ client_id = m_sound->playSoundAt(name, loop, gain, pos, pitch);
// TODO: Set up sound to move with object
break;
}
*pkt >> server_id;
- UNORDERED_MAP<s32, int>::iterator i = m_sounds_server_to_client.find(server_id);
+ std::unordered_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);
*pkt >> sound_id >> step >> gain;
- UNORDERED_MAP<s32, int>::iterator i =
+ std::unordered_map<s32, int>::const_iterator i =
m_sounds_server_to_client.find(sound_id);
if (i != m_sounds_server_to_client.end())
*pkt >> formname;
- ClientEvent event;
- event.type = CE_SHOW_FORMSPEC;
+ ClientEvent *event = new ClientEvent();
+ 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);
+ event->show_formspec.formspec = new std::string(formspec);
+ event->show_formspec.formname = new std::string(formname);
m_client_event_queue.push(event);
}
std::string texture = deSerializeLongString(is);
bool vertical = false;
bool collision_removal = false;
- struct TileAnimationParams animation;
+ TileAnimationParams animation;
animation.type = TAT_NONE;
u8 glow = 0;
try {
glow = 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.collision_removal = collision_removal;
- event.spawn_particle.vertical = vertical;
- event.spawn_particle.texture = new std::string(texture);
- event.spawn_particle.animation = animation;
- event.spawn_particle.glow = glow;
+ ClientEvent *event = new ClientEvent();
+ 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.collision_removal = collision_removal;
+ event->spawn_particle.vertical = vertical;
+ event->spawn_particle.texture = new std::string(texture);
+ event->spawn_particle.animation = animation;
+ event->spawn_particle.glow = glow;
m_client_event_queue.push(event);
}
bool vertical = false;
bool collision_removal = false;
- struct TileAnimationParams animation;
+ TileAnimationParams animation;
animation.type = TAT_NONE;
u8 glow = 0;
u16 attached_id = 0;
glow = readU8(is);
} 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.collision_removal = collision_removal;
- event.add_particlespawner.attached_id = attached_id;
- event.add_particlespawner.vertical = vertical;
- event.add_particlespawner.texture = new std::string(texture);
- event.add_particlespawner.id = id;
- event.add_particlespawner.animation = animation;
- event.add_particlespawner.glow = glow;
+ ClientEvent *event = new ClientEvent();
+ 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.collision_removal = collision_removal;
+ event->add_particlespawner.attached_id = attached_id;
+ event->add_particlespawner.vertical = vertical;
+ event->add_particlespawner.texture = new std::string(texture);
+ event->add_particlespawner.id = id;
+ event->add_particlespawner.animation = animation;
+ event->add_particlespawner.glow = glow;
m_client_event_queue.push(event);
}
void Client::handleCommand_DeleteParticleSpawner(NetworkPacket* pkt)
{
- u16 legacy_id;
u32 id;
+ *pkt >> id;
- // Modification set 13/03/15, 1 year of compat for protocol v24
- if (pkt->getCommand() == TOCLIENT_DELETE_PARTICLESPAWNER_LEGACY) {
- *pkt >> legacy_id;
- }
- else {
- *pkt >> id;
- }
-
-
- ClientEvent event;
- event.type = CE_DELETE_PARTICLESPAWNER;
- event.delete_particlespawner.id =
- (pkt->getCommand() == TOCLIENT_DELETE_PARTICLESPAWNER_LEGACY ? (u32) legacy_id : id);
+ ClientEvent *event = new ClientEvent();
+ event->type = CE_DELETE_PARTICLESPAWNER;
+ event->delete_particlespawner.id = id;
m_client_event_queue.push(event);
}
*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);
+ ClientEvent *event = new ClientEvent();
+ 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(event);
}
*pkt >> id;
- ClientEvent event;
- event.type = CE_HUDRM;
- event.hudrm.id = id;
+ ClientEvent *event = new ClientEvent();
+ event->type = CE_HUDRM;
+ event->hudrm.id = id;
m_client_event_queue.push(event);
}
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);
+ ClientEvent *event = new ClientEvent();
+ 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(event);
}
assert(player != NULL);
bool was_minimap_visible = player->hud_flags & HUD_FLAG_MINIMAP_VISIBLE;
+ bool was_minimap_radar_visible = player->hud_flags & HUD_FLAG_MINIMAP_RADAR_VISIBLE;
player->hud_flags &= ~mask;
player->hud_flags |= flags;
m_minimap_disabled_by_server = !(player->hud_flags & HUD_FLAG_MINIMAP_VISIBLE);
+ bool m_minimap_radar_disabled_by_server = !(player->hud_flags & HUD_FLAG_MINIMAP_RADAR_VISIBLE);
// Hide minimap if it has been disabled by the server
- if (m_minimap_disabled_by_server && was_minimap_visible) {
+ if (m_minimap && m_minimap_disabled_by_server && was_minimap_visible)
// defers a minimap update, therefore only call it if really
// needed, by checking that minimap was visible before
m_minimap->setMinimapMode(MINIMAP_MODE_OFF);
- }
+
+ // Switch to surface mode if radar disabled by server
+ if (m_minimap && m_minimap_radar_disabled_by_server && was_minimap_radar_visible)
+ m_minimap->setMinimapMode(MINIMAP_MODE_SURFACEx1);
}
void Client::handleCommand_HudSetParam(NetworkPacket* pkt)
player->hud_hotbar_itemcount = hotbar_itemcount;
}
else if (param == HUD_PARAM_HOTBAR_IMAGE) {
+ // If value not empty verify image exists in texture source
+ if (!value.empty() && !getTextureSource()->isKnownSourceImage(value)) {
+ errorstream << "Server sent wrong Hud hotbar image (sent value: '"
+ << value << "')" << std::endl;
+ return;
+ }
player->hotbar_image = value;
}
else if (param == HUD_PARAM_HOTBAR_SELECTED_IMAGE) {
+ // If value not empty verify image exists in texture source
+ if (!value.empty() && !getTextureSource()->isKnownSourceImage(value)) {
+ errorstream << "Server sent wrong Hud hotbar selected image (sent value: '"
+ << value << "')" << std::endl;
+ return;
+ }
player->hotbar_selected_image = value;
}
}
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;
+ bool clouds = true;
+ try {
+ clouds = readU8(is);
+ } catch (...) {}
+
+ ClientEvent *event = new ClientEvent();
+ event->type = CE_SET_SKY;
+ event->set_sky.bgcolor = bgcolor;
+ event->set_sky.type = type;
+ event->set_sky.params = params;
+ event->set_sky.clouds = clouds;
m_client_event_queue.push(event);
}
*pkt >> density >> color_bright >> color_ambient
>> height >> thickness >> speed;
- ClientEvent event;
- event.type = CE_CLOUD_PARAMS;
- event.cloud_params.density = density;
+ ClientEvent *event = new ClientEvent();
+ event->type = CE_CLOUD_PARAMS;
+ event->cloud_params.density = density;
// use the underlying u32 representation, because we can't
// use struct members with constructors here, and this way
// we avoid using new() and delete() for no good reason
- event.cloud_params.color_bright = color_bright.color;
- event.cloud_params.color_ambient = color_ambient.color;
- event.cloud_params.height = height;
- event.cloud_params.thickness = thickness;
+ event->cloud_params.color_bright = color_bright.color;
+ event->cloud_params.color_ambient = color_ambient.color;
+ event->cloud_params.height = height;
+ event->cloud_params.thickness = thickness;
// same here: deconstruct to skip constructor
- event.cloud_params.speed_x = speed.X;
- event.cloud_params.speed_y = speed.Y;
+ event->cloud_params.speed_x = speed.X;
+ event->cloud_params.speed_y = speed.Y;
m_client_event_queue.push(event);
}
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;
+ ClientEvent *event = new ClientEvent();
+ 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(event);
}
*pkt >> player->eye_offset_first >> player->eye_offset_third;
}
+void Client::handleCommand_UpdatePlayerList(NetworkPacket* pkt)
+{
+ u8 type;
+ u16 num_players;
+ *pkt >> type >> num_players;
+ PlayerListModifer notice_type = (PlayerListModifer) type;
+
+ for (u16 i = 0; i < num_players; i++) {
+ std::string name;
+ *pkt >> name;
+ switch (notice_type) {
+ case PLAYER_LIST_INIT:
+ case PLAYER_LIST_ADD:
+ m_env.addPlayerName(name);
+ continue;
+ case PLAYER_LIST_REMOVE:
+ m_env.removePlayerName(name);
+ continue;
+ }
+ }
+}
+
void Client::handleCommand_SrpBytesSandB(NetworkPacket* pkt)
{
- if ((m_chosen_auth_mech != AUTH_MECHANISM_LEGACY_PASSWORD)
- && (m_chosen_auth_mech != AUTH_MECHANISM_SRP)) {
- errorstream << "Client: Recieved SRP S_B login message,"
+ if (m_chosen_auth_mech != AUTH_MECHANISM_SRP &&
+ m_chosen_auth_mech != AUTH_MECHANISM_LEGACY_PASSWORD) {
+ errorstream << "Client: Received SRP S_B login message,"
<< " but wasn't supposed to (chosen_mech="
<< m_chosen_auth_mech << ")." << std::endl;
return;
std::string B;
*pkt >> s >> B;
- infostream << "Client: Recieved TOCLIENT_SRP_BYTES_S_B." << std::endl;
+ infostream << "Client: Received TOCLIENT_SRP_BYTES_S_B." << std::endl;
srp_user_process_challenge(usr, (const unsigned char *) s.c_str(), s.size(),
(const unsigned char *) B.c_str(), B.size(),
resp_pkt << std::string(bytes_M, len_M);
Send(&resp_pkt);
}
+
+void Client::handleCommand_CSMFlavourLimits(NetworkPacket *pkt)
+{
+ *pkt >> m_csm_flavour_limits >> m_csm_noderange_limit;
+}
+
+/*
+ * Mod channels
+ */
+
+void Client::handleCommand_ModChannelMsg(NetworkPacket *pkt)
+{
+ std::string channel_name, sender, channel_msg;
+ *pkt >> channel_name >> sender >> channel_msg;
+
+ verbosestream << "Mod channel message received from server " << pkt->getPeerId()
+ << " on channel " << channel_name << ". sender: `" << sender << "`, message: "
+ << channel_msg << std::endl;
+
+ if (!m_modchannel_mgr->channelRegistered(channel_name)) {
+ verbosestream << "Server sent us messages on unregistered channel "
+ << channel_name << ", ignoring." << std::endl;
+ return;
+ }
+
+ m_script->on_modchannel_message(channel_name, sender, channel_msg);
+}
+
+void Client::handleCommand_ModChannelSignal(NetworkPacket *pkt)
+{
+ u8 signal_tmp;
+ ModChannelSignal signal;
+ std::string channel;
+
+ *pkt >> signal_tmp >> channel;
+
+ signal = (ModChannelSignal)signal_tmp;
+
+ bool valid_signal = true;
+ // @TODO: send Signal to Lua API
+ switch (signal) {
+ case MODCHANNEL_SIGNAL_JOIN_OK:
+ m_modchannel_mgr->setChannelState(channel, MODCHANNEL_STATE_READ_WRITE);
+ infostream << "Server ack our mod channel join on channel `" << channel
+ << "`, joining." << std::endl;
+ break;
+ case MODCHANNEL_SIGNAL_JOIN_FAILURE:
+ // Unable to join, remove channel
+ m_modchannel_mgr->leaveChannel(channel, 0);
+ infostream << "Server refused our mod channel join on channel `" << channel
+ << "`" << std::endl;
+ break;
+ case MODCHANNEL_SIGNAL_LEAVE_OK:
+#ifndef NDEBUG
+ infostream << "Server ack our mod channel leave on channel " << channel
+ << "`, leaving." << std::endl;
+#endif
+ break;
+ case MODCHANNEL_SIGNAL_LEAVE_FAILURE:
+ infostream << "Server refused our mod channel leave on channel `" << channel
+ << "`" << std::endl;
+ break;
+ case MODCHANNEL_SIGNAL_CHANNEL_NOT_REGISTERED:
+#ifndef NDEBUG
+ // Generally unused, but ensure we don't do an implementation error
+ infostream << "Server tells us we sent a message on channel `" << channel
+ << "` but we are not registered. Message was dropped." << std::endl;
+#endif
+ break;
+ case MODCHANNEL_SIGNAL_SET_STATE: {
+ u8 state;
+ *pkt >> state;
+
+ if (state == MODCHANNEL_STATE_INIT || state >= MODCHANNEL_STATE_MAX) {
+ infostream << "Received wrong channel state " << state
+ << ", ignoring." << std::endl;
+ return;
+ }
+
+ m_modchannel_mgr->setChannelState(channel, (ModChannelState) state);
+ infostream << "Server sets mod channel `" << channel
+ << "` in read-only mode." << std::endl;
+ break;
+ }
+ default:
+#ifndef NDEBUG
+ warningstream << "Received unhandled mod channel signal ID "
+ << signal << ", ignoring." << std::endl;
+#endif
+ valid_signal = false;
+ break;
+ }
+
+ // If signal is valid, forward it to client side mods
+ if (valid_signal)
+ m_script->on_modchannel_signal(channel, signal);
+}
projects / dragonfireclient.git / blobdiff