/* Minetest Copyright (C) 2010-2013 celeron55, Perttu Ahola 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 "content_sao.h" #include "collision.h" #include "environment.h" #include "settings.h" #include "main.h" // For g_profiler #include "profiler.h" #include "serialization.h" // For compressZlib #include "tool.h" // For ToolCapabilities #include "gamedef.h" #include "player.h" #include "cpp_api/scriptapi.h" #include "genericobject.h" #include "util/serialize.h" std::map ServerActiveObject::m_types; /* DummyLoadSAO */ class DummyLoadSAO : public ServerActiveObject { public: DummyLoadSAO(ServerEnvironment *env, v3f pos, u8 type): ServerActiveObject(env, pos) { ServerActiveObject::registerType(type, create); } // Pretend to be the test object (to fool the client) u8 getType() const { return ACTIVEOBJECT_TYPE_TEST; } // And never save to disk bool isStaticAllowed() const { return false; } static ServerActiveObject* create(ServerEnvironment *env, v3f pos, const std::string &data) { return new DummyLoadSAO(env, pos, 0); } void step(float dtime, bool send_recommended) { m_removed = true; infostream<<"DummyLoadSAO step"< 10) { m_removed = true; return; } m_base_position.Y += dtime * BS * 2; if(m_base_position.Y > 8*BS) m_base_position.Y = 2*BS; if(send_recommended == false) return; m_timer1 -= dtime; if(m_timer1 < 0.0) { m_timer1 += 0.125; std::string data; data += itos(0); // 0 = position data += " "; data += itos(m_base_position.X); data += " "; data += itos(m_base_position.Y); data += " "; data += itos(m_base_position.Z); ActiveObjectMessage aom(getId(), false, data); m_messages_out.push_back(aom); } } bool getCollisionBox(aabb3f *toset) { return false; } bool collideWithObjects() { return false; } private: float m_timer1; float m_age; }; // Prototype (registers item for deserialization) TestSAO proto_TestSAO(NULL, v3f(0,0,0)); /* ItemSAO DEPRECATED: New dropped items are implemented in Lua; see builtin/item_entity.lua. */ class ItemSAO : public ServerActiveObject { public: u8 getType() const { return ACTIVEOBJECT_TYPE_ITEM; } float getMinimumSavedMovement() { return 0.1*BS; } static ServerActiveObject* create(ServerEnvironment *env, v3f pos, const std::string &data) { std::istringstream is(data, std::ios::binary); char buf[1]; // read version is.read(buf, 1); u8 version = buf[0]; // check if version is supported if(version != 0) return NULL; std::string itemstring = deSerializeString(is); infostream<<"create(): Creating item \"" < box(-BS/3.,0.0,-BS/3., BS/3.,BS*2./3.,BS/3.); collisionMoveResult moveresult; // Apply gravity m_speed_f += v3f(0, -dtime*9.81*BS, 0); // Maximum movement without glitches f32 pos_max_d = BS*0.25; // Limit speed if(m_speed_f.getLength()*dtime > pos_max_d) m_speed_f *= pos_max_d / (m_speed_f.getLength()*dtime); v3f pos_f = getBasePosition(); v3f pos_f_old = pos_f; v3f accel_f = v3f(0,0,0); f32 stepheight = 0; moveresult = collisionMoveSimple(m_env,m_env->getGameDef(), pos_max_d, box, stepheight, dtime, pos_f, m_speed_f, accel_f); if(send_recommended == false) return; if(pos_f.getDistanceFrom(m_last_sent_position) > 0.05*BS) { setBasePosition(pos_f); m_last_sent_position = pos_f; std::ostringstream os(std::ios::binary); // command (0 = update position) writeU8(os, 0); // pos writeV3F1000(os, m_base_position); // create message and add to list ActiveObjectMessage aom(getId(), false, os.str()); m_messages_out.push_back(aom); } if(m_itemstring_changed) { m_itemstring_changed = false; std::ostringstream os(std::ios::binary); // command (1 = update itemstring) writeU8(os, 1); // itemstring os<getGameDef()->idef(); ItemStack item; item.deSerialize(m_itemstring, idef); infostream<<__FUNCTION_NAME<<": m_itemstring=\""< item=\""<getInventory(); if(inv != NULL) { std::string wieldlist = puncher->getWieldList(); ItemStack leftover = inv->addItem(wieldlist, item); puncher->setInventoryModified(); if(leftover.empty()) { m_removed = true; } else { m_itemstring = leftover.getItemString(); m_itemstring_changed = true; } } return 0; } bool getCollisionBox(aabb3f *toset) { return false; } bool collideWithObjects() { return false; } private: std::string m_itemstring; bool m_itemstring_changed; v3f m_speed_f; v3f m_last_sent_position; IntervalLimiter m_move_interval; }; // Proto/* Minetest Copyright (C) 2017 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 <cassert> #include <log.h> #include "lua_api/l_modchannels.h" #include "l_internal.h" #include "modchannels.h" int ModApiChannels::l_mod_channel_join(lua_State *L) { if (!lua_isstring(L, 1)) return 0; std::string channel = luaL_checkstring(L, 1); if (channel.empty()) return 0; getGameDef(L)->joinModChannel(channel); assert(getGameDef(L)->getModChannel(channel) != nullptr); ModChannelRef::create(L, channel); int object = lua_gettop(L); lua_pushvalue(L, object); return 1; } void ModApiChannels::Initialize(lua_State *L, int top) { API_FCT(mod_channel_join); } /* * ModChannelRef */ ModChannelRef::ModChannelRef(const std::string &modchannel) : m_modchannel_name(modchannel) { } int ModChannelRef::l_leave(lua_State *L) { ModChannelRef *ref = checkobject(L, 1); getGameDef(L)->leaveModChannel(ref->m_modchannel_name); return 0; } int ModChannelRef::l_send_all(lua_State *L) { ModChannelRef *ref = checkobject(L, 1); ModChannel *channel = getobject(L, ref); if (!channel || !channel->canWrite()) return 0; // @TODO serialize message std::string message = luaL_checkstring(L, 2); getGameDef(L)->sendModChannelMessage(channel->getName(), message); return 0; } int ModChannelRef::l_is_writeable(lua_State *L) { ModChannelRef *ref = checkobject(L, 1); ModChannel *channel = getobject(L, ref); if (!channel) return 0; lua_pushboolean(L, channel->canWrite()); return 1; } void ModChannelRef::Register(lua_State *L) { lua_newtable(L); int methodtable = lua_gettop(L); luaL_newmetatable(L, className); int metatable = lua_gettop(L); lua_pushliteral(L, "__metatable"); lua_pushvalue(L, methodtable); lua_settable(L, metatable); // hide metatable from lua getmetatable() lua_pushliteral(L, "__index"); lua_pushvalue(L, methodtable); lua_settable(L, metatable); lua_pushliteral(L, "__gc"); lua_pushcfunction(L, gc_object); lua_settable(L, metatable); lua_pop(L, 1); // Drop metatable luaL_openlib(L, 0, methods, 0); // fill methodtable lua_pop(L, 1); // Drop methodtable } void ModChannelRef::create(lua_State *L, const std::string &channel) { ModChannelRef *o = new ModChannelRef(channel); *(void **)(lua_newuserdata(L, sizeof(void *))) = o; luaL_getmetatable(L, className); lua_setmetatable(L, -2); } int ModChannelRef::gc_object(lua_State *L) { ModChannelRef *o = *(ModChannelRef **)(lua_touserdata(L, 1)); delete o; return 0; } ModChannelRef *ModChannelRef::checkobject(lua_State *L, int narg) { luaL_checktype(L, narg, LUA_TUSERDATA); void *ud = luaL_checkudata(L, narg, className); if (!ud) luaL_typerror(L, narg, className); return *(ModChannelRef **)ud; // unbox pointer } ModChannel *ModChannelRef::getobject(lua_State *L, ModChannelRef *ref) { return getGameDef(L)->getModChannel(ref->m_modchannel_name); } // clang-format off const char ModChannelRef::className[] = "ModChannelRef"; const luaL_Reg ModChannelRef::methods[] = { luamethod(ModChannelRef, leave), luamethod(ModChannelRef, is_writeable), luamethod(ModChannelRef, send_all), {0, 0}, }; // clang-format on
generated by cgit v1.2.3 (git 2.39.1) at 2025-01-08 14:28:56 +0000
name writeU8(os, 1); // is_player writeS16(os, getId()); //id writeV3F1000(os, m_player->getPosition() + v3f(0,BS*1,0)); writeF1000(os, m_player->getYaw()); writeS16(os, getHP()); writeU8(os, 5 + m_bone_position.size()); // number of messages stuffed in here os< >::const_iterator ii = m_bone_position.begin(); ii != m_bone_position.end(); ++ii){ os<getName()); // name writeU8(os, 1); // is_player writeV3F1000(os, m_player->getPosition() + v3f(0,BS*1,0)); writeF1000(os, m_player->getYaw()); writeS16(os, getHP()); writeU8(os, 2); // number of messages stuffed in here os<getActiveObject(m_attachment_parent_id); if(obj) return true; return false; } void PlayerSAO::step(float dtime, bool send_recommended) { if(!m_properties_sent) { m_properties_sent = true; std::string str = getPropertyPacket(); // create message and add to list ActiveObjectMessage aom(getId(), true, str); m_messages_out.push_back(aom); } // If attached, check that our parent is still there. If it isn't, detach. if(m_attachment_parent_id && !isAttached()) { m_attachment_parent_id = 0; m_attachment_bone = ""; m_attachment_position = v3f(0,0,0); m_attachment_rotation = v3f(0,0,0); m_player->setPosition(m_last_good_position); m_moved = true; } m_time_from_last_punch += dtime; m_nocheat_dig_time += dtime; // Each frame, parent position is copied if the object is attached, otherwise it's calculated normally // If the object gets detached this comes into effect automatically from the last known origin if(isAttached()) { v3f pos = m_env->getActiveObject(m_attachment_parent_id)->getBasePosition(); m_last_good_position = pos; m_last_good_position_age = 0; m_player->setPosition(pos); } else { if(m_is_singleplayer || g_settings->getBool("disable_anticheat")) { m_last_good_position = m_player->getPosition(); m_last_good_position_age = 0; } else { /* Check player movements NOTE: Actually the server should handle player physics like the client does and compare player's position to what is calculated on our side. This is required when eg. players fly due to an explosion. Altough a node-based alternative might be possible too, and much more lightweight. */ float player_max_speed = 0; float player_max_speed_up = 0; if(m_privs.count("fast") != 0){ // Fast speed player_max_speed = BS * 20; player_max_speed_up = BS * 20; } else { // Normal speed player_max_speed = BS * 4.0; player_max_speed_up = BS * 4.0; } // Tolerance player_max_speed *= 2.5; player_max_speed_up *= 2.5; m_last_good_position_age += dtime; if(m_last_good_position_age >= 1.0){ float age = m_last_good_position_age; v3f diff = (m_player->getPosition() - m_last_good_position); float d_vert = diff.Y; diff.Y = 0; float d_horiz = diff.getLength(); /*infostream<getName()<<"'s horizontal speed is " <<(d_horiz/age)<getPosition(); } else { actionstream<<"Player "<getName() <<" moved too fast; resetting position" <setPosition(m_last_good_position); m_moved = true; } m_last_good_position_age = 0; } } } if(send_recommended == false) return; // If the object is attached client-side, don't waste bandwidth sending its position to clients if(m_position_not_sent && !isAttached()) { m_position_not_sent = false; float update_interval = m_env->getSendRecommendedInterval(); v3f pos; if(isAttached()) // Just in case we ever do send attachment position too pos = m_env->getActiveObject(m_attachment_parent_id)->getBasePosition(); else pos = m_player->getPosition() + v3f(0,BS*1,0); std::string str = gob_cmd_update_position( pos, v3f(0,0,0), v3f(0,0,0), m_player->getYaw(), true, false, update_interval ); // create message and add to list ActiveObjectMessage aom(getId(), false, str); m_messages_out.push_back(aom); } if(m_wielded_item_not_sent) { m_wielded_item_not_sent = false; // GenericCAO has no special way to show this } if(m_armor_groups_sent == false){ m_armor_groups_sent = true; std::string str = gob_cmd_update_armor_groups( m_armor_groups); // create message and add to list ActiveObjectMessage aom(getId(), true, str); m_messages_out.push_back(aom); } if(m_physics_override_sent == false){ m_physics_override_sent = true; std::string str = gob_cmd_update_physics_override(m_physics_override_speed, m_physics_override_jump, m_physics_override_gravity); // create message and add to list ActiveObjectMessage aom(getId(), true, str); m_messages_out.push_back(aom); } if(m_animation_sent == false){ m_animation_sent = true; std::string str = gob_cmd_update_animation(m_animation_range, m_animation_speed, m_animation_blend); // create message and add to list ActiveObjectMessage aom(getId(), true, str); m_messages_out.push_back(aom); } if(m_bone_position_sent == false){ m_bone_position_sent = true; for(std::map >::const_iterator ii = m_bone_position.begin(); ii != m_bone_position.end(); ++ii){ std::string str = gob_cmd_update_bone_position((*ii).first, (*ii).second.X, (*ii).second.Y); // create message and add to list ActiveObjectMessage aom(getId(), true, str); m_messages_out.push_back(aom); } } if(m_attachment_sent == false){ m_attachment_sent = true; std::string str = gob_cmd_update_attachment(m_attachment_parent_id, m_attachment_bone, m_attachment_position, m_attachment_rotation); // create message and add to list ActiveObjectMessage aom(getId(), true, str); m_messages_out.push_back(aom); } } void PlayerSAO::setBasePosition(const v3f &position) { // This needs to be ran for attachments too ServerActiveObject::setBasePosition(position); m_position_not_sent = true; } void PlayerSAO::setPos(v3f pos) { if(isAttached()) return; m_player->setPosition(pos); // Movement caused by this command is always valid m_last_good_position = pos; m_last_good_position_age = 0; // Force position change on client m_moved = true; } void PlayerSAO::moveTo(v3f pos, bool continuous) { if(isAttached()) return; m_player->setPosition(pos); // Movement caused by this command is always valid m_last_good_position = pos; m_last_good_position_age = 0; // Force position change on client m_moved = true; } void PlayerSAO::setYaw(float yaw) { m_player->setYaw(yaw); // Force change on client m_moved = true; } void PlayerSAO::setPitch(float pitch) { m_player->setPitch(pitch); // Force change on client m_moved = true; } int PlayerSAO::punch(v3f dir, const ToolCapabilities *toolcap, ServerActiveObject *puncher, float time_from_last_punch) { // It's best that attachments cannot be punched if(isAttached()) return 0; if(!toolcap) return 0; // No effect if PvP disabled if(g_settings->getBool("enable_pvp") == false){ if(puncher->getType() == ACTIVEOBJECT_TYPE_PLAYER){ std::string str = gob_cmd_punched(0, getHP()); // create message and add to list ActiveObjectMessage aom(getId(), true, str); m_messages_out.push_back(aom); return 0; } } HitParams hitparams = getHitParams(m_armor_groups, toolcap, time_from_last_punch); std::string punchername = "nil"; if ( puncher != 0 ) punchername = puncher->getDescription(); actionstream<<"Player "<getName()<<" punched by " <hp; } void PlayerSAO::setHP(s16 hp) { s16 oldhp = m_player->hp; if(hp < 0) hp = 0; else if(hp > PLAYER_MAX_HP) hp = PLAYER_MAX_HP; if(hp < oldhp && g_settings->getBool("enable_damage") == false) { m_hp_not_sent = true; // fix wrong prediction on client return; } m_player->hp = hp; if(hp != oldhp) m_hp_not_sent = true; // On death or reincarnation send an active object message if((hp == 0) != (oldhp == 0)) { // Will send new is_visible value based on (getHP()!=0) m_properties_sent = false; // Send new HP std::string str = gob_cmd_punched(0, getHP()); ActiveObjectMessage aom(getId(), true, str); m_messages_out.push_back(aom); } } u16 PlayerSAO::getBreath() const { return m_player->getBreath(); } void PlayerSAO::setBreath(u16 breath) { m_player->setBreath(breath); } void PlayerSAO::setArmorGroups(const ItemGroupList &armor_groups) { m_armor_groups = armor_groups; m_armor_groups_sent = false; } void PlayerSAO::setAnimation(v2f frame_range, float frame_speed, float frame_blend) { // store these so they can be updated to clients m_animation_range = frame_range; m_animation_speed = frame_speed; m_animation_blend = frame_blend; m_animation_sent = false; } void PlayerSAO::setBonePosition(std::string bone, v3f position, v3f rotation) { // store these so they can be updated to clients m_bone_position[bone] = core::vector2d(position, rotation); m_bone_position_sent = false; } void PlayerSAO::setAttachment(int parent_id, std::string bone, v3f position, v3f rotation) { // Attachments need to be handled on both the server and client. // If we just attach on the server, we can only copy the position of the parent. Attachments // are still sent to clients at an interval so players might see them lagging, plus we can't // read and attach to skeletal bones. // If we just attach on the client, the server still sees the child at its original location. // This breaks some things so we also give the server the most accurate representation // even if players only see the client changes. m_attachment_parent_id = parent_id; m_attachment_bone = bone; m_attachment_position = position; m_attachment_rotation = rotation; m_attachment_sent = false; } ObjectProperties* PlayerSAO::accessObjectProperties() { return &m_prop; } void PlayerSAO::notifyObjectPropertiesModified() { m_properties_sent = false; } Inventory* PlayerSAO::getInventory() { return m_inventory; } const Inventory* PlayerSAO::getInventory() const { return m_inventory; } InventoryLocation PlayerSAO::getInventoryLocation() const { InventoryLocation loc; loc.setPlayer(m_player->getName()); return loc; } void PlayerSAO::setInventoryModified() { m_inventory_not_sent = true; } std::string PlayerSAO::getWieldList() const { return "main"; } int PlayerSAO::getWieldIndex() const { return m_wield_index; } void PlayerSAO::setWieldIndex(int i) { if(i != m_wield_index) { m_wield_index = i; m_wielded_item_not_sent = true; } } void PlayerSAO::disconnected() { m_peer_id = 0; m_removed = true; if(m_player->getPlayerSAO() == this) { m_player->setPlayerSAO(NULL); m_player->peer_id = 0; } } std::string PlayerSAO::getPropertyPacket() { m_prop.is_visible = (true); return gob_cmd_set_properties(m_prop); } bool PlayerSAO::getCollisionBox(aabb3f *toset) { //update collision box *toset = m_player->getCollisionbox(); toset->MinEdge += m_base_position; toset->MaxEdge += m_base_position; return true; } bool PlayerSAO::collideWithObjects(){ return true; }