diff --git a/doc/lua_api.md b/doc/lua_api.md index 796a0f39e..1c16fbe1f 100644 --- a/doc/lua_api.md +++ b/doc/lua_api.md @@ -3660,6 +3660,16 @@ Player Inventory lists * `hand`: list containing an override for the empty hand * Is not created automatically, use `InvRef:set_size` * Is only used to enhance the empty hand's tool capabilities +* `offhand`: list containing the offhand wielded item. + * Is not created automatically, use `InvRef:set_size` + * Will be used for placements and secondary uses if the + main hand does not have any node_place_prediction, on_place + or on_secondary_use callbacks. + * Is passed to on_place and on_secondary_use callbacks; make sure + mods are aware of the itemstack not neccessarily being + located in the main hand. + * The offhand item cannot have its own range or liquids_pointable and + will always reuse the characteristics from the hand item. ItemStack transaction order --------------------------- @@ -9173,18 +9183,18 @@ Used by `minetest.register_node`, `minetest.register_craftitem`, and }, on_place = function(itemstack, placer, pointed_thing), - -- When the 'place' key was pressed with the item in hand + -- When the 'place' key was pressed with the item one of the hands -- and a node was pointed at. + -- 'itemstack' may be the offhand item in cases where the main hand has + -- no on_place handler and no node_placement_prediction. -- Shall place item and return the leftover itemstack -- or nil to not modify the inventory. -- The placer may be any ObjectRef or nil. -- default: minetest.item_place on_secondary_use = function(itemstack, user, pointed_thing), - -- Same as on_place but called when not pointing at a node. - -- Function must return either nil if inventory shall not be modified, - -- or an itemstack to replace the original itemstack. - -- The user may be any ObjectRef or nil. + -- Same as on_place but called when not pointing at a node, + -- whereas `user` is the same as `placer` above. -- default: nil on_drop = function(itemstack, dropper, pos), diff --git a/src/client/camera.cpp b/src/client/camera.cpp index fda9948e9..674fe3757 100644 --- a/src/client/camera.cpp +++ b/src/client/camera.cpp @@ -45,6 +45,236 @@ with this program; if not, write to the Free Software Foundation, Inc., #define WIELDMESH_AMPLITUDE_X 7.0f #define WIELDMESH_AMPLITUDE_Y 10.0f +// Returns the fractional part of x +inline f32 my_modf(f32 x) +{ + f32 dummy; + return modff(x, &dummy); +} + +WieldNode::WieldNode(HandIndex index, Client *client, scene::ISceneManager *mgr) : + m_index(index), + m_direction(index == MAINHAND ? +1 : -1), + m_client(client), + m_meshnode(new WieldMeshSceneNode(mgr, -1, false)), + m_player_light_color(0xFFFFFFFF) +{ + m_meshnode->setItem(ItemStack(), m_client); + m_meshnode->drop(); // mgr grabbed it +} + +void WieldNode::step(f32 dtime) +{ + bool was_under_zero = m_change_timer < 0; + m_change_timer = MYMIN(m_change_timer + dtime, 0.125); + + if (m_change_timer >= 0 && was_under_zero) { + m_meshnode->setItem(m_item_next, m_client); + m_meshnode->setNodeLightColor(m_player_light_color); + } + + if (m_digging_button == -1) + return; + + f32 offset = dtime * 3.5f; + float m_digging_anim_was = m_digging_anim; + m_digging_anim += offset; + if (m_digging_anim >= 1) + { + m_digging_anim = 0; + m_digging_button = -1; + } + float lim = 0.15; + if(m_digging_anim_was < lim && m_digging_anim >= lim) + { + if (m_digging_button == 0) { + m_client->getEventManager()->put(new SimpleTriggerEvent(MtEvent::CAMERA_PUNCH_LEFT)); + } else if(m_digging_button == 1) { + m_client->getEventManager()->put(new SimpleTriggerEvent(MtEvent::CAMERA_PUNCH_RIGHT)); + } + } +} + +static inline v2f dir(const v2f &pos_dist) +{ + f32 x = pos_dist.X - WIELDMESH_OFFSET_X; + f32 y = pos_dist.Y - WIELDMESH_OFFSET_Y; + + f32 x_abs = std::fabs(x); + f32 y_abs = std::fabs(y); + + if (x_abs >= y_abs) { + y *= (1.0f / x_abs); + x /= x_abs; + } + + if (y_abs >= x_abs) { + x *= (1.0f / y_abs); + y /= y_abs; + } + + return v2f(std::fabs(x), std::fabs(y)); +} + +void WieldNode::addArmInertia(f32 player_yaw, v3f camera_direction) +{ + m_cam_vel.X = std::fabs(rangelim(m_last_cam_pos.X - player_yaw, + -100.0f, 100.0f) / 0.016f) * 0.01f; + m_cam_vel.Y = std::fabs((m_last_cam_pos.Y - camera_direction.Y) / 0.016f); + f32 gap_X = std::fabs(WIELDMESH_OFFSET_X - m_offset.X); + f32 gap_Y = std::fabs(WIELDMESH_OFFSET_Y - m_offset.Y); + + if (m_cam_vel.X > 1.0f || m_cam_vel.Y > 1.0f) { + /* + The arm moves relative to the camera speed, + with an acceleration factor. + */ + + if (m_cam_vel.X > 1.0f) { + if (m_cam_vel.X > m_cam_vel_old.X) + m_cam_vel_old.X = m_cam_vel.X; + + f32 acc_X = 0.12f * (m_cam_vel.X - (gap_X * 0.1f)); + m_offset.X += (m_last_cam_pos.X < player_yaw ? acc_X : -acc_X) * m_direction; + + if (m_last_cam_pos.X != player_yaw) + m_last_cam_pos.X = player_yaw; + + m_offset.X = rangelim(m_offset.X, + WIELDMESH_OFFSET_X - (WIELDMESH_AMPLITUDE_X * 0.5f), + WIELDMESH_OFFSET_X + (WIELDMESH_AMPLITUDE_X * 0.5f)); + } + + if (m_cam_vel.Y > 1.0f) { + if (m_cam_vel.Y > m_cam_vel_old.Y) + m_cam_vel_old.Y = m_cam_vel.Y; + + f32 acc_Y = 0.12f * (m_cam_vel.Y - (gap_Y * 0.1f)); + m_offset.Y += + m_last_cam_pos.Y > camera_direction.Y ? acc_Y : -acc_Y; + + if (m_last_cam_pos.Y != camera_direction.Y) + m_last_cam_pos.Y = camera_direction.Y; + + m_offset.Y = rangelim(m_offset.Y, + WIELDMESH_OFFSET_Y - (WIELDMESH_AMPLITUDE_Y * 0.5f), + WIELDMESH_OFFSET_Y + (WIELDMESH_AMPLITUDE_Y * 0.5f)); + } + + m_arm_dir = dir(m_offset); + } else { + /* + Now the arm gets back to its default position when the camera stops, + following a vector, with a smooth deceleration factor. + */ + + f32 dec_X = 0.35f * (std::min(15.0f, m_cam_vel_old.X) * (1.0f + + (1.0f - m_arm_dir.X))) * (gap_X / 20.0f); + + f32 dec_Y = 0.25f * (std::min(15.0f, m_cam_vel_old.Y) * (1.0f + + (1.0f - m_arm_dir.Y))) * (gap_Y / 15.0f); + + if (gap_X < 0.1f) + m_cam_vel_old.X = 0.0f; + + m_offset.X -= + m_offset.X > WIELDMESH_OFFSET_X ? dec_X : -dec_X; + + if (gap_Y < 0.1f) + m_cam_vel_old.Y = 0.0f; + + m_offset.Y -= + m_offset.Y > WIELDMESH_OFFSET_Y ? dec_Y : -dec_Y; + } +} + +void WieldNode::update(video::SColor player_light_color, f32 view_bobbing_anim, f32 tool_reload_ratio) +{ + m_player_light_color = player_light_color; + + // Position the wielded item + //v3f pos = v3f(45, -35, 65); + v3f pos = v3f(m_offset.X, m_offset.Y, 65); + //v3f rot = v3f(-100, 120, -100); + v3f rot = v3f(-100, 120, -100); + + if (m_index == OFFHAND) + tool_reload_ratio = 1.0f; + + pos.Y += fabs(m_change_timer)*320 - 40; + if(m_digging_anim < 0.05 || m_digging_anim > 0.5) + { + f32 frac = 1.0; + if(m_digging_anim > 0.5) + frac = 2.0 * (m_digging_anim - 0.5); + // This value starts from 1 and settles to 0 + f32 ratiothing = std::pow((1.0f - tool_reload_ratio), 0.5f); + //f32 ratiothing2 = pow(ratiothing, 0.5f); + f32 ratiothing2 = (easeCurve(ratiothing*0.5))*2.0; + pos.Y -= frac * 25.0 * pow(ratiothing2, 1.7f); + //rot.Z += frac * 5.0 * ratiothing2; + pos.X -= frac * 35.0 * pow(ratiothing2, 1.1f); + rot.Y += frac * 70.0 * pow(ratiothing2, 1.4f); + //rot.X -= frac * 15.0 * pow(ratiothing2, 1.4f); + //rot.Z += frac * 15.0 * pow(ratiothing2, 1.0f); + } + if (m_digging_button != -1) + { + f32 digfrac = m_digging_anim; + pos.X -= 50 * sin(pow(digfrac, 0.8f) * M_PI); + pos.Y += 24 * sin(digfrac * 1.8 * M_PI); + pos.Z += 25 * 0.5; + + // Euler angles are PURE EVIL, so why not use quaternions? + core::quaternion quat_begin(rot * core::DEGTORAD); + //core::quaternion quat_end(v3f(s * 80, 30, s * 100) * core::DEGTORAD); + core::quaternion quat_end(v3f(80, 30, 100) * core::DEGTORAD); + core::quaternion quat_slerp; + quat_slerp.slerp(quat_begin, quat_end, sin(digfrac * M_PI)); + quat_slerp.W *= m_direction; + quat_slerp.X *= m_direction; + quat_slerp.toEuler(rot); + rot *= core::RADTODEG; + pos.X *= m_direction; + } else { + f32 bobfrac = my_modf(view_bobbing_anim); + pos.X *= m_direction; + pos.X -= sin(bobfrac*M_PI*2.0+M_PI*m_index) * 3.0 * m_direction; + pos.Y += sin(my_modf(bobfrac*2.0)*M_PI+M_PI*m_index) * 3.0; + } + + m_meshnode->setPosition(pos); + m_meshnode->setRotation(rot); + + m_meshnode->setNodeLightColor(m_player_light_color); + + if (m_index == OFFHAND) { + m_meshnode->setVisible( + m_change_timer > 0 ? !m_item_next.name.empty() : m_item_old); + } + +} + +void WieldNode::setDigging(s32 button) +{ + if (m_digging_button == -1) + m_digging_button = button; +} + +void WieldNode::wield(const ItemStack &item) +{ + if (item.name == m_item_next.name && + item.metadata == m_item_next.metadata) + return; + + m_item_old = m_item_next.name != ""; + m_item_next = item; + if (m_change_timer > 0) + m_change_timer = -m_change_timer; + else if (m_change_timer == 0) + m_change_timer = -0.001; +} + Camera::Camera(MapDrawControl &draw_control, Client *client, RenderingEngine *rendering_engine): m_draw_control(draw_control), m_client(client), @@ -62,9 +292,9 @@ Camera::Camera(MapDrawControl &draw_control, Client *client, RenderingEngine *re // all other 3D scene nodes and before the GUI. m_wieldmgr = smgr->createNewSceneManager(); m_wieldmgr->addCameraSceneNode(); - m_wieldnode = new WieldMeshSceneNode(m_wieldmgr, -1, false); - m_wieldnode->setItem(ItemStack(), m_client); - m_wieldnode->drop(); // m_wieldmgr grabbed it + + m_wieldnodes[MAINHAND] = new WieldNode(MAINHAND, m_client, m_wieldmgr); + m_wieldnodes[ OFFHAND] = new WieldNode( OFFHAND, m_client, m_wieldmgr); /* TODO: Add a callback function so these can be updated when a setting * changes. At this point in time it doesn't matter (e.g. /set @@ -87,6 +317,8 @@ Camera::Camera(MapDrawControl &draw_control, Client *client, RenderingEngine *re Camera::~Camera() { + for (auto node : m_wieldnodes) + delete node; m_wieldmgr->drop(); } @@ -144,6 +376,9 @@ inline f32 my_modf(f32 x) void Camera::step(f32 dtime) { + for (auto node : m_wieldnodes) + node->step(dtime); + if(m_view_bobbing_fall > 0) { m_view_bobbing_fall -= 3 * dtime; @@ -218,97 +453,10 @@ void Camera::step(f32 dtime) } } -static inline v2f dir(const v2f &pos_dist) -{ - f32 x = pos_dist.X - WIELDMESH_OFFSET_X; - f32 y = pos_dist.Y - WIELDMESH_OFFSET_Y; - - f32 x_abs = std::fabs(x); - f32 y_abs = std::fabs(y); - - if (x_abs >= y_abs) { - y *= (1.0f / x_abs); - x /= x_abs; - } - - if (y_abs >= x_abs) { - x *= (1.0f / y_abs); - y /= y_abs; - } - - return v2f(std::fabs(x), std::fabs(y)); -} - void Camera::addArmInertia(f32 player_yaw) { - m_cam_vel.X = std::fabs(rangelim(m_last_cam_pos.X - player_yaw, - -100.0f, 100.0f) / 0.016f) * 0.01f; - m_cam_vel.Y = std::fabs((m_last_cam_pos.Y - m_camera_direction.Y) / 0.016f); - f32 gap_X = std::fabs(WIELDMESH_OFFSET_X - m_wieldmesh_offset.X); - f32 gap_Y = std::fabs(WIELDMESH_OFFSET_Y - m_wieldmesh_offset.Y); - - if (m_cam_vel.X > 1.0f || m_cam_vel.Y > 1.0f) { - /* - The arm moves relative to the camera speed, - with an acceleration factor. - */ - - if (m_cam_vel.X > 1.0f) { - if (m_cam_vel.X > m_cam_vel_old.X) - m_cam_vel_old.X = m_cam_vel.X; - - f32 acc_X = 0.12f * (m_cam_vel.X - (gap_X * 0.1f)); - m_wieldmesh_offset.X += m_last_cam_pos.X < player_yaw ? acc_X : -acc_X; - - if (m_last_cam_pos.X != player_yaw) - m_last_cam_pos.X = player_yaw; - - m_wieldmesh_offset.X = rangelim(m_wieldmesh_offset.X, - WIELDMESH_OFFSET_X - (WIELDMESH_AMPLITUDE_X * 0.5f), - WIELDMESH_OFFSET_X + (WIELDMESH_AMPLITUDE_X * 0.5f)); - } - - if (m_cam_vel.Y > 1.0f) { - if (m_cam_vel.Y > m_cam_vel_old.Y) - m_cam_vel_old.Y = m_cam_vel.Y; - - f32 acc_Y = 0.12f * (m_cam_vel.Y - (gap_Y * 0.1f)); - m_wieldmesh_offset.Y += - m_last_cam_pos.Y > m_camera_direction.Y ? acc_Y : -acc_Y; - - if (m_last_cam_pos.Y != m_camera_direction.Y) - m_last_cam_pos.Y = m_camera_direction.Y; - - m_wieldmesh_offset.Y = rangelim(m_wieldmesh_offset.Y, - WIELDMESH_OFFSET_Y - (WIELDMESH_AMPLITUDE_Y * 0.5f), - WIELDMESH_OFFSET_Y + (WIELDMESH_AMPLITUDE_Y * 0.5f)); - } - - m_arm_dir = dir(m_wieldmesh_offset); - } else { - /* - Now the arm gets back to its default position when the camera stops, - following a vector, with a smooth deceleration factor. - */ - - f32 dec_X = 0.35f * (std::min(15.0f, m_cam_vel_old.X) * (1.0f + - (1.0f - m_arm_dir.X))) * (gap_X / 20.0f); - - f32 dec_Y = 0.25f * (std::min(15.0f, m_cam_vel_old.Y) * (1.0f + - (1.0f - m_arm_dir.Y))) * (gap_Y / 15.0f); - - if (gap_X < 0.1f) - m_cam_vel_old.X = 0.0f; - - m_wieldmesh_offset.X -= - m_wieldmesh_offset.X > WIELDMESH_OFFSET_X ? dec_X : -dec_X; - - if (gap_Y < 0.1f) - m_cam_vel_old.Y = 0.0f; - - m_wieldmesh_offset.Y -= - m_wieldmesh_offset.Y > WIELDMESH_OFFSET_Y ? dec_Y : -dec_Y; - } + for (auto node : m_wieldnodes) + node->addArmInertia(player_yaw, m_camera_direction); } void Camera::update(LocalPlayer* player, f32 frametime, f32 tool_reload_ratio) @@ -530,46 +678,10 @@ void Camera::update(LocalPlayer* player, f32 frametime, f32 tool_reload_ratio) if (m_arm_inertia) addArmInertia(yaw); - // Position the wielded item - v3f wield_position = v3f(m_wieldmesh_offset.X, m_wieldmesh_offset.Y, 65); - v3f wield_rotation = v3f(-100, 120, -100); - wield_position.Y += std::abs(m_wield_change_timer)*320 - 40; - if(m_digging_anim < 0.05 || m_digging_anim > 0.5) - { - f32 frac = 1.0; - if(m_digging_anim > 0.5) - frac = 2.0 * (m_digging_anim - 0.5); - // This value starts from 1 and settles to 0 - f32 ratiothing = std::pow((1.0f - tool_reload_ratio), 0.5f); - f32 ratiothing2 = (easeCurve(ratiothing*0.5))*2.0; - wield_position.Y -= frac * 25.0f * std::pow(ratiothing2, 1.7f); - wield_position.X -= frac * 35.0f * std::pow(ratiothing2, 1.1f); - wield_rotation.Y += frac * 70.0f * std::pow(ratiothing2, 1.4f); - } - if (m_digging_button != -1) - { - f32 digfrac = m_digging_anim; - wield_position.X -= 50 * std::sin(std::pow(digfrac, 0.8f) * M_PI); - wield_position.Y += 24 * std::sin(digfrac * 1.8 * M_PI); - wield_position.Z += 25 * 0.5; - - // Euler angles are PURE EVIL, so why not use quaternions? - core::quaternion quat_begin(wield_rotation * core::DEGTORAD); - core::quaternion quat_end(v3f(80, 30, 100) * core::DEGTORAD); - core::quaternion quat_slerp; - quat_slerp.slerp(quat_begin, quat_end, std::sin(digfrac * M_PI)); - quat_slerp.toEuler(wield_rotation); - wield_rotation *= core::RADTODEG; - } else { - f32 bobfrac = my_modf(m_view_bobbing_anim); - wield_position.X -= std::sin(bobfrac*M_PI*2.0) * 3.0; - wield_position.Y += std::sin(my_modf(bobfrac*2.0)*M_PI) * 3.0; - } - m_wieldnode->setPosition(wield_position); - m_wieldnode->setRotation(wield_rotation); - m_player_light_color = player->light_color; - m_wieldnode->setNodeLightColor(m_player_light_color); + + for (auto node : m_wieldnodes) + node->update(m_player_light_color, m_view_bobbing_anim, tool_reload_ratio); // Set render distance updateViewingRange(); @@ -611,22 +723,14 @@ void Camera::updateViewingRange() m_cameranode->setFarValue((viewing_range < 2000) ? 2000 * BS : viewing_range * BS); } -void Camera::setDigging(s32 button) +void Camera::setDigging(s32 button, HandIndex hand) { - if (m_digging_button == -1) - m_digging_button = button; + m_wieldnodes[hand]->setDigging(button); } -void Camera::wield(const ItemStack &item) +void Camera::wield(const ItemStack &item, HandIndex hand) { - if (item.name != m_wield_item_next.name || - item.metadata != m_wield_item_next.metadata) { - m_wield_item_next = item; - if (m_wield_change_timer > 0) - m_wield_change_timer = -m_wield_change_timer; - else if (m_wield_change_timer == 0) - m_wield_change_timer = -0.001; - } + m_wieldnodes[hand]->wield(item); } void Camera::drawWieldedTool(irr::core::matrix4* translation) diff --git a/src/client/camera.h b/src/client/camera.h index d6aa0bc54..d33b99039 100644 --- a/src/client/camera.h +++ b/src/client/camera.h @@ -72,6 +72,49 @@ struct Nametag } }; +enum HandIndex { MAINHAND = 0, OFFHAND = 1 }; + +class WieldNode +{ +public: + WieldNode(HandIndex index, Client *client, scene::ISceneManager *mgr); + void step(f32 dtime); + void addArmInertia(f32 player_yaw, v3f camera_direction); + void update(video::SColor player_light_color, f32 view_bobbing_anim, f32 tool_reload_ratio); + void setDigging(s32 button); + void wield(const ItemStack &item); + +private: + HandIndex m_index; + int m_direction; + + Client *m_client; + WieldMeshSceneNode *m_meshnode = nullptr; + + // Digging animation frame (0 <= m_digging_anim < 1) + f32 m_digging_anim = 0.0f; + + // If -1, no digging animation + // If 0, left-click digging animation + // If 1, right-click digging animation + s32 m_digging_button = -1; + + // Animation when changing wielded item + f32 m_change_timer = 0.125f; + ItemStack m_item_next; + bool m_item_old = false; + + // Last known light color of the player + video::SColor m_player_light_color; + + // Arm inertia + v2f m_offset = v2f(55.0f, -35.0f); + v2f m_arm_dir; + v2f m_cam_vel; + v2f m_cam_vel_old; + v2f m_last_cam_pos; +}; + enum CameraMode {CAMERA_MODE_FIRST, CAMERA_MODE_THIRD, CAMERA_MODE_THIRD_FRONT}; /* @@ -166,11 +209,11 @@ class Camera void updateViewingRange(); // Start digging animation - // Pass 0 for left click, 1 for right click - void setDigging(s32 button); + // button: Pass 0 for left click, 1 for right click + void setDigging(s32 button, HandIndex hand); // Replace the wielded item mesh - void wield(const ItemStack &item); + void wield(const ItemStack &item, HandIndex hand); // Draw the wielded tool. // This has to happen *after* the main scene is drawn. @@ -219,8 +262,9 @@ class Camera scene::ISceneNode *m_headnode = nullptr; scene::ICameraSceneNode *m_cameranode = nullptr; + WieldNode *m_wieldnodes[2]; + scene::ISceneManager *m_wieldmgr = nullptr; - WieldMeshSceneNode *m_wieldnode = nullptr; // draw control MapDrawControl& m_draw_control; @@ -247,12 +291,6 @@ class Camera bool m_fov_transition_active = false; f32 m_fov_diff, m_transition_time; - v2f m_wieldmesh_offset = v2f(55.0f, -35.0f); - v2f m_arm_dir; - v2f m_cam_vel; - v2f m_cam_vel_old; - v2f m_last_cam_pos; - // Field of view and aspect ratio stuff f32 m_aspect = 1.0f; f32 m_fov_x = 1.0f; @@ -269,17 +307,6 @@ class Camera // Fall view bobbing f32 m_view_bobbing_fall = 0.0f; - // Digging animation frame (0 <= m_digging_anim < 1) - f32 m_digging_anim = 0.0f; - // If -1, no digging animation - // If 0, left-click digging animation - // If 1, right-click digging animation - s32 m_digging_button = -1; - - // Animation when changing wielded item - f32 m_wield_change_timer = 0.125f; - ItemStack m_wield_item_next; - CameraMode m_camera_mode = CAMERA_MODE_FIRST; f32 m_cache_fall_bobbing_amount; diff --git a/src/client/client.cpp b/src/client/client.cpp index ca3f91e78..0572f5207 100644 --- a/src/client/client.cpp +++ b/src/client/client.cpp @@ -1570,6 +1570,8 @@ bool Client::updateWieldedItem() list->setModified(false); if (auto *list = player->inventory.getList("hand")) list->setModified(false); + if (auto *list = player->inventory.getList("offhand")) + list->setModified(false); return true; } diff --git a/src/client/game.cpp b/src/client/game.cpp index 55ec480b5..0084c795c 100644 --- a/src/client/game.cpp +++ b/src/client/game.cpp @@ -777,7 +777,8 @@ class Game { bool look_for_object, const v3s16 &camera_offset); void handlePointingAtNothing(const ItemStack &playerItem); void handlePointingAtNode(const PointedThing &pointed, - const ItemStack &selected_item, const ItemStack &hand_item, f32 dtime); + const ItemStack &selected_item, const ItemStack &hand_item, + const ItemStack &place_item, f32 dtime); void handlePointingAtObject(const PointedThing &pointed, const ItemStack &playeritem, const v3f &player_position, bool show_debug); void handleDigging(const PointedThing &pointed, const v3s16 &nodepos, @@ -1834,19 +1835,19 @@ inline bool Game::handleCallbacks() if (g_gamecallback->changepassword_requested) { (new GUIPasswordChange(guienv, guiroot, -1, - &g_menumgr, client, texture_src))->drop(); + &g_menumgr, client, texture_src))->drop(); g_gamecallback->changepassword_requested = false; } if (g_gamecallback->changevolume_requested) { (new GUIVolumeChange(guienv, guiroot, -1, - &g_menumgr, texture_src))->drop(); + &g_menumgr, texture_src))->drop(); g_gamecallback->changevolume_requested = false; } if (g_gamecallback->keyconfig_requested) { (new GUIKeyChangeMenu(guienv, guiroot, -1, - &g_menumgr, texture_src))->drop(); + &g_menumgr, texture_src))->drop(); g_gamecallback->keyconfig_requested = false; } @@ -3270,7 +3271,7 @@ void Game::processPlayerInteraction(f32 dtime, bool show_hud) Calculate what block is the crosshair pointing to */ - ItemStack selected_item, hand_item; + ItemStack selected_item, hand_item, offhand_item, place_item; const ItemStack &tool_item = player->getWieldedItem(&selected_item, &hand_item); const ItemDefinition &selected_def = selected_item.getDefinition(itemdef_manager); @@ -3310,6 +3311,8 @@ void Game::processPlayerInteraction(f32 dtime, bool show_hud) !runData.btn_down_for_dig, camera_offset); + player->getOffhandWieldedItem(&offhand_item, &place_item, itemdef_manager, pointed); + if (pointed != runData.pointed_old) infostream << "Pointing at " << pointed.dump() << std::endl; @@ -3380,7 +3383,7 @@ void Game::processPlayerInteraction(f32 dtime, bool show_hud) !client->getScript()->on_item_use(selected_item, pointed))) client->interact(INTERACT_USE, pointed); } else if (pointed.type == POINTEDTHING_NODE) { - handlePointingAtNode(pointed, selected_item, hand_item, dtime); + handlePointingAtNode(pointed, selected_item, hand_item, place_item, dtime); } else if (pointed.type == POINTEDTHING_OBJECT) { v3f player_position = player->getPosition(); bool basic_debug_allowed = client->checkPrivilege("debug") || (player->hud_flags & HUD_FLAG_BASIC_DEBUG); @@ -3393,13 +3396,13 @@ void Game::processPlayerInteraction(f32 dtime, bool show_hud) if (wasKeyPressed(KeyType::DIG) && client->modsLoaded()) client->getScript()->on_item_use(selected_item, pointed); } else if (wasKeyPressed(KeyType::PLACE)) { - handlePointingAtNothing(selected_item); + handlePointingAtNothing(place_item); } runData.pointed_old = pointed; if (runData.punching || wasKeyPressed(KeyType::DIG)) - camera->setDigging(0); // dig animation + camera->setDigging(0, MAINHAND); // dig animation input->clearWasKeyPressed(); input->clearWasKeyReleased(); @@ -3524,7 +3527,8 @@ void Game::handlePointingAtNothing(const ItemStack &playerItem) void Game::handlePointingAtNode(const PointedThing &pointed, - const ItemStack &selected_item, const ItemStack &hand_item, f32 dtime) + const ItemStack &selected_item, const ItemStack &hand_item, + const ItemStack &place_item, f32 dtime) { v3s16 nodepos = pointed.node_undersurface; v3s16 neighborpos = pointed.node_abovesurface; @@ -3562,7 +3566,10 @@ void Game::handlePointingAtNode(const PointedThing &pointed, infostream << "Place button pressed while looking at ground" << std::endl; // Placing animation (always shown for feedback) - camera->setDigging(1); + if (place_item == selected_item) + camera->setDigging(1, MAINHAND); + else + camera->setDigging(1, OFFHAND); soundmaker->m_player_rightpunch_sound = SoundSpec(); @@ -3570,8 +3577,8 @@ void Game::handlePointingAtNode(const PointedThing &pointed, // make that happen // And also set the sound and send the interact // But first check for meta formspec and rightclickable - auto &def = selected_item.getDefinition(itemdef_manager); - bool placed = nodePlacement(def, selected_item, nodepos, neighborpos, + auto &def = place_item.getDefinition(itemdef_manager); + bool placed = nodePlacement(def, place_item, nodepos, neighborpos, pointed, meta); if (placed && client->modsLoaded()) @@ -3995,7 +4002,7 @@ void Game::handleDigging(const PointedThing &pointed, const v3s16 &nodepos, client->setCrack(-1, nodepos); } - camera->setDigging(0); // Dig animation + camera->setDigging(0, MAINHAND); // Dig animation } void Game::updateFrame(ProfilerGraph *graph, RunStats *stats, f32 dtime, @@ -4042,7 +4049,7 @@ void Game::updateFrame(ProfilerGraph *graph, RunStats *stats, f32 dtime, direct_brightness = client->getEnv().getClientMap() .getBackgroundBrightness(MYMIN(runData.fog_range * 1.2, 60 * BS), daynight_ratio, (int)(old_brightness * 255.5), &sunlight_seen) - / 255.0; + / 255.0; } float time_of_day_smooth = runData.time_of_day_smooth; @@ -4113,9 +4120,11 @@ void Game::updateFrame(ProfilerGraph *graph, RunStats *stats, f32 dtime, if (client->updateWieldedItem()) { // Update wielded tool - ItemStack selected_item, hand_item; + ItemStack selected_item, hand_item, offhand_item; ItemStack &tool_item = player->getWieldedItem(&selected_item, &hand_item); - camera->wield(tool_item); + camera->wield(tool_item, MAINHAND); + player->getOffhandWieldedItem(&offhand_item, nullptr, itemdef_manager, PointedThing()); + camera->wield(offhand_item, OFFHAND); } /* diff --git a/src/itemdef.cpp b/src/itemdef.cpp index ad2ed4847..51c6215a5 100644 --- a/src/itemdef.cpp +++ b/src/itemdef.cpp @@ -142,6 +142,8 @@ ItemDefinition& ItemDefinition::operator=(const ItemDefinition &def) node_placement_prediction = def.node_placement_prediction; place_param2 = def.place_param2; wallmounted_rotate_vertical = def.wallmounted_rotate_vertical; + has_on_place = def.has_on_place; + has_on_secondary_use = def.has_on_secondary_use; sound_place = def.sound_place; sound_place_failed = def.sound_place_failed; sound_use = def.sound_use; @@ -195,6 +197,8 @@ void ItemDefinition::reset() node_placement_prediction.clear(); place_param2.reset(); wallmounted_rotate_vertical = false; + has_on_place = false; + has_on_secondary_use = false; touch_interaction = TouchInteraction(); } @@ -252,6 +256,9 @@ void ItemDefinition::serialize(std::ostream &os, u16 protocol_version) const sound_use.serializeSimple(os, protocol_version); sound_use_air.serializeSimple(os, protocol_version); + writeU8(os, has_on_place); + writeU8(os, has_on_secondary_use); + os << (u8)place_param2.has_value(); // protocol_version >= 43 if (place_param2) os << *place_param2; @@ -340,6 +347,9 @@ void ItemDefinition::deSerialize(std::istream &is, u16 protocol_version) sound_use.deSerializeSimple(is, protocol_version); sound_use_air.deSerializeSimple(is, protocol_version); + has_on_place = readU8(is); + has_on_secondary_use = readU8(is); + if (is.eof()) throw SerializationError(""); diff --git a/src/itemdef.h b/src/itemdef.h index 782dad816..3020afdd3 100644 --- a/src/itemdef.h +++ b/src/itemdef.h @@ -121,6 +121,10 @@ struct ItemDefinition // "" = no prediction std::string node_placement_prediction; std::optional place_param2; + + bool has_on_place; + bool has_on_secondary_use; + bool wallmounted_rotate_vertical; TouchInteraction touch_interaction; diff --git a/src/network/serverpackethandler.cpp b/src/network/serverpackethandler.cpp index 2c6f024ee..8a8498892 100644 --- a/src/network/serverpackethandler.cpp +++ b/src/network/serverpackethandler.cpp @@ -893,9 +893,9 @@ void Server::handleCommand_Respawn(NetworkPacket* pkt) bool Server::checkInteractDistance(RemotePlayer *player, const f32 d, const std::string &what) { - ItemStack selected_item, hand_item; - player->getWieldedItem(&selected_item, &hand_item); - f32 max_d = BS * getToolRange(selected_item, hand_item, m_itemdef); + ItemStack selected_item, main_item; + player->getWieldedItem(&selected_item, &main_item); + f32 max_d = BS * getToolRange(selected_item, main_item, m_itemdef); // Cube diagonal * 1.5 for maximal supported node extents: // sqrt(3) * 1.5 ≅ 2.6 @@ -919,6 +919,14 @@ static inline void getWieldedItem(const PlayerSAO *playersao, std::optionalgetWieldedItem(&(*ret)); } +static inline bool getOffhandWieldedItem(const PlayerSAO *playersao, Optional &offhand, + Optional &place, IItemDefManager *idef, const PointedThing &pointed) +{ + offhand = ItemStack(); + place = ItemStack(); + return playersao->getOffhandWieldedItem(&(*offhand), &(*place), idef, pointed); +} + void Server::handleCommand_Interact(NetworkPacket *pkt) { /* @@ -1159,8 +1167,8 @@ void Server::handleCommand_Interact(NetworkPacket *pkt) // Get player's wielded item // See also: Game::handleDigging - ItemStack selected_item, hand_item; - player->getWieldedItem(&selected_item, &hand_item); + ItemStack selected_item, main_item; + player->getWieldedItem(&selected_item, &main_item); // Get diggability and expected digging time DigParams params = getDigParams(m_nodedef->get(n).groups, @@ -1169,7 +1177,7 @@ void Server::handleCommand_Interact(NetworkPacket *pkt) // If can't dig, try hand if (!params.diggable) { params = getDigParams(m_nodedef->get(n).groups, - &hand_item.getToolCapabilities(m_itemdef)); + &main_item.getToolCapabilities(m_itemdef)); } // If can't dig, ignore dig if (!params.diggable) { @@ -1227,15 +1235,16 @@ void Server::handleCommand_Interact(NetworkPacket *pkt) // Place block or right-click object case INTERACT_PLACE: { - std::optional selected_item; - getWieldedItem(playersao, selected_item); + std::optional main_item, offhand_item, place_item; + getWieldedItem(playersao, main_item); + bool use_offhand = getOffhandWieldedItem(playersao, offhand_item, place_item, m_itemdef, pointed); // Reset build time counter if (pointed.type == POINTEDTHING_NODE && - selected_item->getDefinition(m_itemdef).type == ITEM_NODE) + place_item->getDefinition(m_itemdef).type == ITEM_NODE) getClient(peer_id)->m_time_from_building = 0.0; - const bool had_prediction = !selected_item->getDefinition(m_itemdef). + const bool had_prediction = !place_item->getDefinition(m_itemdef). node_placement_prediction.empty(); if (pointed.type == POINTEDTHING_OBJECT) { @@ -1250,18 +1259,22 @@ void Server::handleCommand_Interact(NetworkPacket *pkt) << pointed_object->getDescription() << std::endl; // Do stuff - if (m_script->item_OnSecondaryUse(selected_item, playersao, pointed)) { - if (selected_item.has_value() && playersao->setWieldedItem(*selected_item)) - SendInventory(player, true); + if (m_script->item_OnSecondaryUse(use_offhand ? offhand_item : main_item, playersao, pointed)) { + if (use_offhand + ? (offhand_item.has_value() && playersao->setOffhandWieldedItem(*offhand_item)) + : (main_item.has_value() && playersao->setWieldedItem(*main_item))) + SendInventory(playersao, true); } pointed_object->rightClick(playersao); - } else if (m_script->item_OnPlace(selected_item, playersao, pointed)) { + } else if (m_script->item_OnPlace(use_offhand ? offhand_item : main_item, playersao, pointed)) { // Placement was handled in lua // Apply returned ItemStack - if (selected_item.has_value() && playersao->setWieldedItem(*selected_item)) - SendInventory(player, true); + if (use_offhand + ? (offhand_item.has_value() && playersao->setOffhandWieldedItem(*offhand_item)) + : (main_item.has_value() && playersao->setWieldedItem(*main_item))) + SendInventory(playersao, true); } if (pointed.type != POINTEDTHING_NODE) @@ -1303,17 +1316,20 @@ void Server::handleCommand_Interact(NetworkPacket *pkt) // Rightclick air case INTERACT_ACTIVATE: { - std::optional selected_item; - getWieldedItem(playersao, selected_item); + std::optional main_item, offhand_item, place_item; + getWieldedItem(playersao, main_item); + bool use_offhand = getOffhandWieldedItem(playersao, offhand_item, place_item, m_itemdef, pointed); actionstream << player->getName() << " activates " - << selected_item->name << std::endl; + << place_item->name << std::endl; pointed.type = POINTEDTHING_NOTHING; // can only ever be NOTHING - if (m_script->item_OnSecondaryUse(selected_item, playersao, pointed)) { + if (m_script->item_OnSecondaryUse(use_offhand ? offhand_item : main_item, playersao, pointed)) { // Apply returned ItemStack - if (selected_item.has_value() && playersao->setWieldedItem(*selected_item)) + if (use_offhand + ? (offhand_item.has_value() && playersao->setOffhandWieldedItem(*offhand_item)) + : (main_item.has_value() && playersao->setWieldedItem(*main_item))) SendInventory(player, true); } diff --git a/src/player.cpp b/src/player.cpp index c876b6948..2079bfea3 100644 --- a/src/player.cpp +++ b/src/player.cpp @@ -105,6 +105,46 @@ ItemStack &Player::getWieldedItem(ItemStack *selected, ItemStack *hand) const return (hand && selected->name.empty()) ? *hand : *selected; } +bool Player::getOffhandWieldedItem(ItemStack *offhand, ItemStack *place, IItemDefManager *idef, const PointedThing &pointed) const +{ + assert(offhand); + + ItemStack main; + + const InventoryList *mlist = inventory.getList("main"); + const InventoryList *olist = inventory.getList("offhand"); + + if (olist) + *offhand = olist->getItem(0); + + if (mlist && m_wield_index < mlist->getSize()) + main = mlist->getItem(m_wield_index); + + const ItemDefinition &main_def = main.getDefinition(idef); + const ItemDefinition &offhand_def = offhand->getDefinition(idef); + bool main_usable, offhand_usable; + + // figure out which item to use for placements + + if (pointed.type == POINTEDTHING_NODE) { + // an item can be used on nodes if it has a place handler or prediction + main_usable = main_def.has_on_place || main_def.node_placement_prediction != ""; + offhand_usable = offhand_def.has_on_place || offhand_def.node_placement_prediction != ""; + } else { + // an item can be used on anything else if it has a secondary use handler + main_usable = main_def.has_on_secondary_use; + offhand_usable = offhand_def.has_on_secondary_use; + } + + // main hand has priority + bool use_offhand = offhand_usable && !main_usable; + + if (place) + *place = use_offhand ? *offhand : main; + + return use_offhand; +} + u32 Player::addHud(HudElement *toadd) { MutexAutoLock lock(m_mutex); diff --git a/src/player.h b/src/player.h index a79a13228..791b6c999 100644 --- a/src/player.h +++ b/src/player.h @@ -24,6 +24,7 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "constants.h" #include "network/networkprotocol.h" #include "util/basic_macros.h" +#include "util/pointedthing.h" #include #include #include @@ -219,6 +220,13 @@ class Player // Returns non-empty `selected` ItemStack. `hand` is a fallback, if specified ItemStack &getWieldedItem(ItemStack *selected, ItemStack *hand) const; + + // item currently in secondary hand is returned in `offhand` + // item to use for place / secondary_use (either main or offhand) is (optionally) returned in `place` + // return value: whether to use main or offhand for placing + bool getOffhandWieldedItem(ItemStack *offhand, ItemStack *place, + IItemDefManager *idef, const PointedThing &pointed) const; + void setWieldIndex(u16 index); u16 getWieldIndex() const { return m_wield_index; } diff --git a/src/script/common/c_content.cpp b/src/script/common/c_content.cpp index de4f2fe02..8b8a37df9 100644 --- a/src/script/common/c_content.cpp +++ b/src/script/common/c_content.cpp @@ -83,6 +83,16 @@ void read_item_definition(lua_State* L, int index, def.usable = lua_isfunction(L, -1); lua_pop(L, 1); + lua_pushstring(L, "on_place"); + lua_rawget(L, index); + def.has_on_place = lua_isfunction(L, -1); + lua_pop(L, 1); + + lua_pushstring(L, "on_secondary_use"); + lua_rawget(L, index); + def.has_on_secondary_use = lua_isfunction(L, -1); + lua_pop(L, 1); + getboolfield(L, index, "liquids_pointable", def.liquids_pointable); lua_getfield(L, index, "pointabilities"); diff --git a/src/server/player_sao.cpp b/src/server/player_sao.cpp index 0806ffd73..fadd3ef3f 100644 --- a/src/server/player_sao.cpp +++ b/src/server/player_sao.cpp @@ -570,6 +570,11 @@ ItemStack PlayerSAO::getWieldedItem(ItemStack *selected, ItemStack *hand) const return m_player->getWieldedItem(selected, hand); } +bool PlayerSAO::getOffhandWieldedItem(ItemStack *offhand, ItemStack *place, IItemDefManager *itemdef_manager, PointedThing pointed) const +{ + return m_player->getOffhandWieldedItem(offhand, place, itemdef_manager, pointed); +} + bool PlayerSAO::setWieldedItem(const ItemStack &item) { InventoryList *mlist = m_player->inventory.getList(getWieldList()); @@ -580,6 +585,16 @@ bool PlayerSAO::setWieldedItem(const ItemStack &item) return false; } +bool PlayerSAO::setOffhandWieldedItem(const ItemStack &item) +{ + InventoryList *olist = m_player->inventory.getList("offhand"); + if (olist) { + olist->changeItem(0, item); + return true; + } + return false; +} + void PlayerSAO::disconnected() { markForRemoval(); diff --git a/src/server/player_sao.h b/src/server/player_sao.h index b26304589..3b54d642a 100644 --- a/src/server/player_sao.h +++ b/src/server/player_sao.h @@ -25,6 +25,7 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "network/networkprotocol.h" #include "unit_sao.h" #include "util/numeric.h" +#include "util/pointedthing.h" /* PlayerSAO needs some internals exposed. @@ -134,7 +135,9 @@ class PlayerSAO : public UnitSAO std::string getWieldList() const override { return "main"; } u16 getWieldIndex() const override; ItemStack getWieldedItem(ItemStack *selected, ItemStack *hand = nullptr) const override; + bool getOffhandWieldedItem(ItemStack *offhand, ItemStack *place, IItemDefManager *itemdef_manager, PointedThing pointed) const; bool setWieldedItem(const ItemStack &item) override; + bool setOffhandWieldedItem(const ItemStack &item); /* PlayerSAO-specific