#include "content_abm.h"
#include "content_sao.h"
#include "mods.h"
-#include "sound.h" // dummySoundManager
#include "event_manager.h"
#include "serverlist.h"
#include "util/string.h"
-#include "util/mathconstants.h"
#include "rollback.h"
#include "util/serialize.h"
#include "util/thread.h"
} catch (con::ConnectionBindFailed &e) {
m_server->setAsyncFatalError(e.what());
} catch (LuaError &e) {
- m_server->setAsyncFatalError("Lua: " + std::string(e.what()));
+ m_server->setAsyncFatalError(
+ "ServerThread::run Lua: " + std::string(e.what()));
}
}
g_settings->get("kick_msg_crash"),
g_settings->getBool("ask_reconnect_on_crash"));
}
- throw ServerError(async_err);
+ throw ServerError("AsyncErr: " + async_err);
}
}
}
m_clients.unlock();
- RemotePlayer *player =
- static_cast<RemotePlayer*>(m_env->getPlayer(playername.c_str()));
+ RemotePlayer *player = m_env->getPlayer(playername.c_str());
// If failed, cancel
if ((playersao == NULL) || (player == NULL)) {
SendPlayerHPOrDie(playersao);
// Send Breath
- SendPlayerBreath(peer_id);
+ SendPlayerBreath(playersao);
// Show death screen if necessary
if (playersao->isDead())
}
// Spawns a particle on peer with peer_id
-void Server::SendSpawnParticle(u16 peer_id, v3f pos, v3f velocity, v3f acceleration,
+void Server::SendSpawnParticle(u16 peer_id, u16 protocol_version,
+ v3f pos, v3f velocity, v3f acceleration,
float expirationtime, float size, bool collisiondetection,
bool collision_removal,
- bool vertical, const std::string &texture)
+ bool vertical, const std::string &texture,
+ const struct TileAnimationParams &animation, u8 glow)
{
DSTACK(FUNCTION_NAME);
+ if (peer_id == PEER_ID_INEXISTENT) {
+ // This sucks and should be replaced by a better solution in a refactor:
+ std::vector<u16> clients = m_clients.getClientIDs();
+ for (std::vector<u16>::iterator i = clients.begin(); i != clients.end(); ++i) {
+ RemotePlayer *player = m_env->getPlayer(*i);
+ if (!player)
+ continue;
+ SendSpawnParticle(*i, player->protocol_version,
+ pos, velocity, acceleration,
+ expirationtime, size, collisiondetection,
+ collision_removal, vertical, texture, animation, glow);
+ }
+ return;
+ }
NetworkPacket pkt(TOCLIENT_SPAWN_PARTICLE, 0, peer_id);
pkt.putLongString(texture);
pkt << vertical;
pkt << collision_removal;
+ // This is horrible but required (why are there two ways to serialize pkts?)
+ std::ostringstream os(std::ios_base::binary);
+ animation.serialize(os, protocol_version);
+ pkt.putRawString(os.str());
+ pkt << glow;
- if (peer_id != PEER_ID_INEXISTENT) {
- Send(&pkt);
- }
- else {
- m_clients.sendToAll(0, &pkt, true);
- }
+ Send(&pkt);
}
// Adds a ParticleSpawner on peer with peer_id
-void Server::SendAddParticleSpawner(u16 peer_id, u16 amount, float spawntime, v3f minpos, v3f maxpos,
+void Server::SendAddParticleSpawner(u16 peer_id, u16 protocol_version,
+ 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, bool collision_removal,
- u16 attached_id, bool vertical, const std::string &texture, u32 id)
+ u16 attached_id, bool vertical, const std::string &texture, u32 id,
+ const struct TileAnimationParams &animation, u8 glow)
{
DSTACK(FUNCTION_NAME);
+ if (peer_id == PEER_ID_INEXISTENT) {
+ // This sucks and should be replaced:
+ std::vector<u16> clients = m_clients.getClientIDs();
+ for (std::vector<u16>::iterator i = clients.begin(); i != clients.end(); ++i) {
+ RemotePlayer *player = m_env->getPlayer(*i);
+ if (!player)
+ continue;
+ SendAddParticleSpawner(*i, player->protocol_version,
+ amount, spawntime, minpos, maxpos,
+ minvel, maxvel, minacc, maxacc, minexptime, maxexptime,
+ minsize, maxsize, collisiondetection, collision_removal,
+ attached_id, vertical, texture, id, animation, glow);
+ }
+ return;
+ }
NetworkPacket pkt(TOCLIENT_ADD_PARTICLESPAWNER, 0, peer_id);
pkt << id << vertical;
pkt << collision_removal;
pkt << attached_id;
+ // This is horrible but required
+ std::ostringstream os(std::ios_base::binary);
+ animation.serialize(os, protocol_version);
+ pkt.putRawString(os.str());
+ pkt << glow;
- if (peer_id != PEER_ID_INEXISTENT) {
- Send(&pkt);
- }
- else {
- m_clients.sendToAll(0, &pkt, true);
- }
+ Send(&pkt);
}
void Server::SendDeleteParticleSpawner(u16 peer_id, u32 id)
playersao->m_messages_out.push(aom);
}
-void Server::SendPlayerBreath(u16 peer_id)
+void Server::SendPlayerBreath(PlayerSAO *sao)
{
DSTACK(FUNCTION_NAME);
- PlayerSAO *playersao = getPlayerSAO(peer_id);
- assert(playersao);
+ assert(sao);
- m_script->player_event(playersao, "breath_changed");
- SendBreath(peer_id, playersao->getBreath());
+ m_script->player_event(sao, "breath_changed");
+ SendBreath(sao->getPeerID(), sao->getBreath());
}
void Server::SendMovePlayer(u16 peer_id)
}
SendPlayerHP(peer_id);
- SendPlayerBreath(peer_id);
}
std::vector<u16> clients = m_clients.getClientIDs();
+ /*
+ Send the message back to the inital sender
+ if they are using protocol version >= 29
+ */
+
u16 peer_id_to_avoid_sending = (player ? player->peer_id : PEER_ID_INEXISTENT);
+ if (player->protocol_version >= 29)
+ peer_id_to_avoid_sending = PEER_ID_INEXISTENT;
+
for (u16 i = 0; i < clients.size(); i++) {
u16 cid = clients[i];
if (cid != peer_id_to_avoid_sending)
v3f velocity, v3f acceleration,
float expirationtime, float size, bool
collisiondetection, bool collision_removal,
- bool vertical, const std::string &texture)
+ bool vertical, const std::string &texture,
+ const struct TileAnimationParams &animation, u8 glow)
{
// m_env will be NULL if the server is initializing
if (!m_env)
return;
- u16 peer_id = PEER_ID_INEXISTENT;
+ u16 peer_id = PEER_ID_INEXISTENT, proto_ver = 0;
if (playername != "") {
RemotePlayer *player = m_env->getPlayer(playername.c_str());
if (!player)
return;
peer_id = player->peer_id;
+ proto_ver = player->protocol_version;
}
- SendSpawnParticle(peer_id, pos, velocity, acceleration,
+ SendSpawnParticle(peer_id, proto_ver, pos, velocity, acceleration,
expirationtime, size, collisiondetection,
- collision_removal, vertical, texture);
+ collision_removal, vertical, texture, animation, glow);
}
u32 Server::addParticleSpawner(u16 amount, float spawntime,
float minexptime, float maxexptime, float minsize, float maxsize,
bool collisiondetection, bool collision_removal,
ServerActiveObject *attached, bool vertical, const std::string &texture,
- const std::string &playername)
+ const std::string &playername, const struct TileAnimationParams &animation,
+ u8 glow)
{
// m_env will be NULL if the server is initializing
if (!m_env)
return -1;
- u16 peer_id = PEER_ID_INEXISTENT;
+ u16 peer_id = PEER_ID_INEXISTENT, proto_ver = 0;
if (playername != "") {
RemotePlayer *player = m_env->getPlayer(playername.c_str());
if (!player)
return -1;
peer_id = player->peer_id;
+ proto_ver = player->protocol_version;
}
u16 attached_id = attached ? attached->getId() : 0;
else
id = m_env->addParticleSpawner(spawntime, attached_id);
- SendAddParticleSpawner(peer_id, amount, spawntime,
+ SendAddParticleSpawner(peer_id, proto_ver, amount, spawntime,
minpos, maxpos, minvel, maxvel, minacc, maxacc,
minexptime, maxexptime, minsize, maxsize,
collisiondetection, collision_removal, attached_id, vertical,
- texture, id);
+ texture, id, animation, glow);
return id;
}
{
return m_craftdef;
}
-ITextureSource *Server::getTextureSource()
-{
- return NULL;
-}
-IShaderSource *Server::getShaderSource()
-{
- return NULL;
-}
-scene::ISceneManager *Server::getSceneManager()
-{
- return NULL;
-}
u16 Server::allocateUnknownNodeId(const std::string &name)
{
return m_nodedef->allocateDummy(name);
}
-ISoundManager *Server::getSoundManager()
-{
- return &dummySoundManager;
-}
-
MtEventManager *Server::getEventManager()
{
return m_event;
projects / dragonfireclient.git / blobdiff