/* 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 "util/serialize.h" #include "util/mathconstants.h" #include "collision.h" #include "environment.h" #include "settings.h" #include "serialization.h" // For compressZlib #include "tool.h" // For ToolCapabilities #include "gamedef.h" #include "player.h" #include "server.h" #include "scripting_game.h" #include "genericobject.h" #include "log.h" std::map ServerActiveObject::m_types; /* TestSAO */ class TestSAO : public ServerActiveObject { public: TestSAO(ServerEnvironment *env, v3f pos): ServerActiveObject(env, pos), m_timer1(0), m_age(0) { ServerActiveObject::registerType(getType(), create); } ActiveObjectType getType() const { return ACTIVEOBJECT_TYPE_TEST; } static ServerActiveObject* create(ServerEnvironment *env, v3f pos, const std::string &data) { return new TestSAO(env, pos); } void step(float dtime, bool send_recommended) { m_age += dtime; if(m_age > 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(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)); /* LuaEntitySAO */ // Prototype (registers item for deserialization) LuaEntitySAO proto_LuaEntitySAO(NULL, v3f(0,0,0), "_prototype", ""); LuaEntitySAO::LuaEntitySAO(ServerEnvironment *env, v3f pos, const std::string &name, const std::string &state): ServerActiveObject(env, pos), m_init_name(name), m_init_state(state), m_registered(false), m_hp(-1), m_velocity(0,0,0), m_acceleration(0,0,0), m_yaw(0), m_properties_sent(true), m_last_sent_yaw(0), m_last_sent_position(0,0,0), m_last_sent_velocity(0,0,0), m_last_sent_position_timer(0), m_last_sent_move_precision(0), m_armor_groups_sent(false), m_animation_speed(0), m_animation_blend(0), m_animation_loop(true), m_animation_sent(false), m_bone_position_sent(false), m_attachment_parent_id(0), m_attachment_sent(false) { // Only register type if no environment supplied if(env == NULL){ ServerActiveObject::registerType(getType(), create); return; } // Initialize something to armor groups m_armor_groups["fleshy"] = 100; } LuaEntitySAO::~LuaEntitySAO() { if(m_registered){ m_env->getScriptIface()->luaentity_Remove(m_id); } } void LuaEntitySAO::addedToEnvironment(u32 dtime_s) { ServerActiveObject::addedToEnvironment(dtime_s); // Create entity from name m_registered = m_env->getScriptIface()-> luaentity_Add(m_id, m_init_name.c_str()); if(m_registered){ // Get properties m_env->getScriptIface()-> luaentity_GetProperties(m_id, &m_prop); // Initialize HP from properties m_hp = m_prop.hp_max; // Activate entity, supplying serialized state m_env->getScriptIface()-> luaentity_Activate(m_id, m_init_state.c_str(), dtime_s); } } ServerActiveObject* LuaEntitySAO::create(ServerEnvironment *env, v3f pos, const std::string &data) { std::string name; std::string state; s16 hp = 1; v3f velocity; float yaw = 0; if(data != ""){ std::istringstream is(data, std::ios::binary); // read version u8 version = readU8(is); // check if version is supported if(version == 0){ name = deSerializeString(is); state = deSerializeLongString(is); } else if(version == 1){ name = deSerializeString(is); state = deSerializeLongString(is); hp = readS16(is); velocity = readV3F1000(is); yaw = readF1000(is); } } // create object infostream<<"LuaEntitySAO::create(name=\""<m_hp = hp; sao->m_velocity = velocity; sao->m_yaw = yaw; return sao; } bool LuaEntitySAO::isAttached() { if(!m_attachment_parent_id) return false; // Check if the parent still exists ServerActiveObject *obj = m_env->getActiveObject(m_attachment_parent_id); if(obj) return true; return false; } void LuaEntitySAO::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(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); sendPosition(false, true); } m_last_sent_position_timer += 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_base_position = pos; m_velocity = v3f(0,0,0); m_acceleration = v3f(0,0,0); } else { if(m_prop.physical){ core::aabbox3d box = m_prop.collisionbox; box.MinEdge *= BS; box.MaxEdge *= BS; collisionMoveResult moveresult; f32 pos_max_d = BS*0.25; // Distance per iteration v3f p_pos = m_base_position; v3f p_velocity = m_velocity; v3f p_acceleration = m_acceleration; moveresult = collisionMoveSimple(m_env,m_env->getGameDef(), pos_max_d, box, m_prop.stepheight, dtime, p_pos, p_velocity, p_acceleration, this, m_prop.collideWithObjects); // Apply results m_base_position = p_pos; m_velocity = p_velocity; m_acceleration = p_acceleration; } else { m_base_position += dtime * m_velocity + 0.5 * dtime * dtime * m_acceleration; m_velocity += dtime * m_acceleration; } if((m_prop.automatic_face_movement_dir) && (fabs(m_velocity.Z) > 0.001 || fabs(m_velocity.X) > 0.001)) { float optimal_yaw = atan2(m_velocity.Z,m_velocity.X) * 180 / M_PI + m_prop.automatic_face_movement_dir_offset; float max_rotation_delta = dtime * m_prop.automatic_face_movement_max_rotation_per_sec; if ((m_prop.automatic_face_movement_max_rotation_per_sec > 0) && (fabs(m_yaw - optimal_yaw) > max_rotation_delta)) { m_yaw = optimal_yaw < m_yaw ? m_yaw - max_rotation_delta : m_yaw + max_rotation_delta; } else { m_yaw = optimal_yaw; } } } if(m_registered){ m_env->getScriptIface()->luaentity_Step(m_id, dtime); } if(send_recommended == false) return; if(!isAttached()) { // TODO: force send when acceleration changes enough? float minchange = 0.2*BS; if(m_last_sent_position_timer > 1.0){ minchange = 0.01*BS; } else if(m_last_sent_position_timer > 0.2){ minchange = 0.05*BS; } float move_d = m_base_ 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 "helper.h" #include <cmath> #include <sstream> #include <irr_v2d.h> #include "c_types.h" #include "c_internal.h" // imported from c_converter.cpp with pure C++ style static inline void check_lua_type(lua_State *L, int index, const char *name, int type) { int t = lua_type(L, index); if (t != type) { std::string traceback = script_get_backtrace(L); throw LuaError(std::string("Invalid ") + (name) + " (expected " + lua_typename(L, (type)) + " got " + lua_typename(L, t) + ").\n" + traceback); } } // imported from c_converter.cpp #define CHECK_POS_COORD(name) \ check_lua_type(L, -1, "position coordinate '" name "'", LUA_TNUMBER) #define CHECK_POS_TAB(index) check_lua_type(L, index, "position", LUA_TTABLE) bool LuaHelper::isNaN(lua_State *L, int idx) { return lua_type(L, idx) == LUA_TNUMBER && std::isnan(lua_tonumber(L, idx)); } /* * Read template functions */ template <> bool LuaHelper::readParam(lua_State *L, int index) { return lua_toboolean(L, index) != 0; } template <> bool LuaHelper::readParam(lua_State *L, int index, const bool &default_value) { if (lua_isnil(L, index)) return default_value; return lua_toboolean(L, index) != 0; } template <> s16 LuaHelper::readParam(lua_State *L, int index) { return lua_tonumber(L, index); } template <> float LuaHelper::readParam(lua_State *L, int index) { if (isNaN(L, index)) throw LuaError("NaN value is not allowed."); return (float)luaL_checknumber(L, index); } template <> v2s16 LuaHelper::readParam(lua_State *L, int index) { v2s16 p; CHECK_POS_TAB(index); lua_getfield(L, index, "x"); CHECK_POS_COORD("x"); p.X = readParam<s16>(L, -1); lua_pop(L, 1); lua_getfield(L, index, "y"); CHECK_POS_COORD("y"); p.Y = readParam<s16>(L, -1); lua_pop(L, 1); return p; } template <> v2f LuaHelper::readParam(lua_State *L, int index) { v2f p; CHECK_POS_TAB(index); lua_getfield(L, index, "x"); CHECK_POS_COORD("x"); p.X = readParam<float>(L, -1); lua_pop(L, 1); lua_getfield(L, index, "y"); CHECK_POS_COORD("y"); p.Y = readParam<float>(L, -1); lua_pop(L, 1); return p; } template <> std::string LuaHelper::readParam(lua_State *L, int index) { size_t length; std::string result; const char *str = luaL_checklstring(L, index, &length); result.assign(str, length); return result; } template <> std::string LuaHelper::readParam( lua_State *L, int index, const std::string &default_value) { std::string result; const char *str = lua_tostring(L, index); if (str) result.append(str); else result = default_value; return result; }
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-13 01:10:52 +0000
Position() + 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(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); ((Server*)m_env->getGameDef())->SendMovePlayer(m_peer_id); } //dstream<<"PlayerSAO::step: dtime: "<getMaxLagEstimate() * 2.0; if(lag_pool_max < LAG_POOL_MIN) lag_pool_max = LAG_POOL_MIN; m_dig_pool.setMax(lag_pool_max); m_move_pool.setMax(lag_pool_max); // Increment cheat prevention timers m_dig_pool.add(dtime); m_move_pool.add(dtime); 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_player->setPosition(pos); } 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(aom); } 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(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, m_physics_override_sneak, m_physics_override_sneak_glitch); // create message and add to list ActiveObjectMessage aom(getId(), true, str); m_messages_out.push(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, m_animation_loop); // create message and add to list ActiveObjectMessage aom(getId(), true, str); m_messages_out.push(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(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(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; ((Server*)m_env->getGameDef())->SendMovePlayer(m_peer_id); } 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; ((Server*)m_env->getGameDef())->SendMovePlayer(m_peer_id); } void PlayerSAO::setYaw(float yaw) { m_player->setYaw(yaw); ((Server*)m_env->getGameDef())->SendMovePlayer(m_peer_id); } void PlayerSAO::setPitch(float pitch) { m_player->setPitch(pitch); ((Server*)m_env->getGameDef())->SendMovePlayer(m_peer_id); } 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(aom); return 0; } } HitParams hitparams = getHitParams(m_armor_groups, toolcap, time_from_last_punch); std::string punchername = "nil"; if (puncher != 0) punchername = puncher->getDescription(); PlayerSAO *playersao = m_player->getPlayerSAO(); bool damage_handled = m_env->getScriptIface()->on_punchplayer(playersao, puncher, time_from_last_punch, toolcap, dir, hitparams.hp); if (!damage_handled) { setHP(getHP() - hitparams.hp); } else { // override client prediction 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(aom); } } actionstream << "Player " << m_player->getName() << " punched by " << punchername; if (!damage_handled) { actionstream << ", damage " << hitparams.hp << " HP"; } else { actionstream << ", damage handled by lua"; } actionstream << std::endl; return hitparams.wear; } void PlayerSAO::rightClick(ServerActiveObject *clicker) { } s16 PlayerSAO::getHP() const { return m_player->hp; } s16 PlayerSAO::readDamage() { s16 damage = m_damage; m_damage = 0; return damage; } void PlayerSAO::setHP(s16 hp) { s16 oldhp = m_player->hp; s16 hp_change = m_env->getScriptIface()->on_player_hpchange(this, hp - oldhp); if (hp_change == 0) return; hp = oldhp + hp_change; if (hp < 0) hp = 0; else if (hp > PLAYER_MAX_HP) hp = PLAYER_MAX_HP; if(hp < oldhp && g_settings->getBool("enable_damage") == false) { return; } m_player->hp = hp; if (oldhp > hp) m_damage += (oldhp - hp); // Update properties on death if ((hp == 0) != (oldhp == 0)) m_properties_sent = false; } 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; } ItemGroupList PlayerSAO::getArmorGroups() { return m_armor_groups; } void PlayerSAO::setAnimation(v2f frame_range, float frame_speed, float frame_blend, bool frame_loop) { // 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_loop = frame_loop; m_animation_sent = false; } void PlayerSAO::getAnimation(v2f *frame_range, float *frame_speed, float *frame_blend, bool *frame_loop) { *frame_range = m_animation_range; *frame_speed = m_animation_speed; *frame_blend = m_animation_blend; *frame_loop = m_animation_loop; } void PlayerSAO::setBonePosition(const 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::getBonePosition(const std::string &bone, v3f *position, v3f *rotation) { *position = m_bone_position[bone].X; *rotation = m_bone_position[bone].Y; } void PlayerSAO::setAttachment(int parent_id, const 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; } void PlayerSAO::getAttachment(int *parent_id, std::string *bone, v3f *position, v3f *rotation) { *parent_id = m_attachment_parent_id; *bone = m_attachment_bone; *position = m_attachment_position; *rotation = m_attachment_rotation; } void PlayerSAO::addAttachmentChild(int child_id) { m_attachment_child_ids.insert(child_id); } void PlayerSAO::removeAttachmentChild(int child_id) { m_attachment_child_ids.erase(child_id); } std::set PlayerSAO::getAttachmentChildIds() { return m_attachment_child_ids; } 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; } 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; } } 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::checkMovementCheat() { bool cheated = false; if(isAttached() || m_is_singleplayer || g_settings->getBool("disable_anticheat")) { m_last_good_position = m_player->getPosition(); } 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; if(m_privs.count("fast") != 0){ // Fast speed player_max_speed = m_player->movement_speed_fast; } else { // Normal speed player_max_speed = m_player->movement_speed_walk; } // Tolerance. With the lag pool we shouldn't need it. //player_max_speed *= 2.5; //player_max_speed_up *= 2.5; v3f diff = (m_player->getPosition() - m_last_good_position); float d_vert = diff.Y; diff.Y = 0; float d_horiz = diff.getLength(); float required_time = d_horiz/player_max_speed; if(d_vert > 0 && d_vert/player_max_speed > required_time) required_time = d_vert/player_max_speed; if(m_move_pool.grab(required_time)){ m_last_good_position = m_player->getPosition(); } else { actionstream<<"Player "<getName() <<" moved too fast; resetting position" <setPosition(m_last_good_position); cheated = true; } } return cheated; } 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; }