if wielded then
local wdef = wielded:get_definition()
local tp = wielded:get_tool_capabilities()
- local dp = core.get_dig_params(def and def.groups, tp)
+ local dp = core.get_dig_params(def and def.groups, tp, wielded:get_wear())
if wdef and wdef.after_use then
wielded = wdef.after_use(wielded, digger, node, dp) or wielded
else
### Uses (tools only)
Determines how many uses the tool has when it is used for digging a node,
-of this group, of the maximum level. For lower leveled nodes, the use count
-is multiplied by `3^leveldiff`.
+of this group, of the maximum level. The maximum supported number of
+uses is 65535. The special number 0 is used for infinite uses.
+For lower leveled nodes, the use count is multiplied by `3^leveldiff`.
`leveldiff` is the difference of the tool's `maxlevel` `groupcaps` and the
node's `level` group. The node cannot be dug if `leveldiff` is less than zero.
* `minetest.pointed_thing_to_face_pos(placer, pointed_thing)`: returns a
position.
* returns the exact position on the surface of a pointed node
-* `minetest.get_dig_params(groups, tool_capabilities)`: Simulates an item
- that digs a node.
+* `minetest.get_dig_params(groups, tool_capabilities [, wear])`:
+ Simulates an item that digs a node.
Returns a table with the following fields:
* `diggable`: `true` if node can be dug, `false` otherwise.
* `time`: Time it would take to dig the node.
Parameters:
* `groups`: Table of the node groups of the node that would be dug
* `tool_capabilities`: Tool capabilities table of the item
-* `minetest.get_hit_params(groups, tool_capabilities [, time_from_last_punch])`:
+ * `wear`: Amount of wear the tool starts with (default: 0)
+* `minetest.get_hit_params(groups, tool_capabilities [, time_from_last_punch [, wear]])`:
Simulates an item that punches an object.
Returns a table with the following fields:
* `hp`: How much damage the punch would cause.
* `groups`: Damage groups of the object
* `tool_capabilities`: Tool capabilities table of the item
* `time_from_last_punch`: time in seconds since last punch action
+ * `wear`: Amount of wear the item starts with (default: 0)
Tool materials:
-* Dirt: dig nodes of rating 3, one use only
* Wood: dig nodes of rating 3
* Stone: dig nodes of rating 3 or 2
* Steel: dig nodes of rating 3, 2 or 1
* Mese: dig "everything" instantly
+* n-Uses: can be used n times before breaking
]]
-- The hand
-- Pickaxes: Dig cracky
--
--- This should break after only 1 use
-minetest.register_tool("basetools:pick_dirt", {
- description = "Dirt Pickaxe".."\n"..
- "Digs cracky=3".."\n"..
- "1 use only",
- inventory_image = "basetools_dirtpick.png",
- tool_capabilities = {
- max_drop_level=0,
- groupcaps={
- cracky={times={[3]=2.00}, uses=1, maxlevel=0}
- },
- },
-})
-
minetest.register_tool("basetools:pick_wood", {
description = "Wooden Pickaxe".."\n"..
"Digs cracky=3",
damage_groups = {fleshy=2},
}
})
+
+-- Test tool uses and punch_attack_uses
+local uses = { 1, 2, 3, 5, 10, 50, 100, 1000, 10000, 65535 }
+for i=1, #uses do
+ local u = uses[i]
+ local color = string.format("#FF00%02X", math.floor(((i-1)/#uses) * 255))
+ minetest.register_tool("basetools:pick_uses_"..string.format("%05d", u), {
+ description = u.."-Uses Pickaxe".."\n"..
+ "Digs cracky=3",
+ inventory_image = "basetools_steelpick.png^[colorize:"..color..":127",
+ tool_capabilities = {
+ max_drop_level=0,
+ groupcaps={
+ cracky={times={[3]=0.1, [2]=0.2, [1]=0.3}, uses=u, maxlevel=0}
+ },
+ },
+ })
+
+ minetest.register_tool("basetools:sword_uses_"..string.format("%05d", u), {
+ description = u.."-Uses Sword".."\n"..
+ "Damage: fleshy=1",
+ inventory_image = "basetools_woodsword.png^[colorize:"..color..":127",
+ tool_capabilities = {
+ damage_groups = {fleshy=1},
+ punch_attack_uses = u,
+ },
+ })
+end
end,
})
+minetest.register_chatcommand("use_tool", {
+ params = "(dig <group> <leveldiff>) | (hit <damage_group> <time_from_last_punch>) [<uses>]",
+ description = "Apply tool wear a number of times, as if it were used for digging",
+ func = function(name, param)
+ local player = minetest.get_player_by_name(name)
+ if not player then
+ return false, "No player."
+ end
+ local mode, group, level, uses = string.match(param, "([a-z]+) ([a-z0-9]+) (-?%d+) (%d+)")
+ if not mode then
+ mode, group, level = string.match(param, "([a-z]+) ([a-z0-9]+) (-?%d+)")
+ uses = 1
+ end
+ if not mode or not group or not level then
+ return false
+ end
+ if mode ~= "dig" and mode ~= "hit" then
+ return false
+ end
+ local tool = player:get_wielded_item()
+ local caps = tool:get_tool_capabilities()
+ if not caps or tool:get_count() == 0 then
+ return false, "No tool in hand."
+ end
+ local actual_uses = 0
+ for u=1, uses do
+ local wear = tool:get_wear()
+ local dp
+ if mode == "dig" then
+ dp = minetest.get_dig_params({[group]=3, level=level}, caps, wear)
+ else
+ dp = minetest.get_hit_params({[group]=100}, caps, level, wear)
+ end
+ tool:add_wear(dp.wear)
+ actual_uses = actual_uses + 1
+ if tool:get_count() == 0 then
+ break
+ end
+ end
+ player:set_wielded_item(tool)
+ if tool:get_count() == 0 then
+ return true, string.format("Tool used %d time(s). "..
+ "The tool broke after %d use(s).", uses, actual_uses)
+ else
+ local wear = tool:get_wear()
+ return true, string.format("Tool used %d time(s). "..
+ "Final wear=%d", uses, wear)
+ end
+ end,
+})
+
+
+
-- Use this to test waypoint capabilities
minetest.register_chatcommand("test_waypoints", {
params = "[change_immediate]",
m_armor_groups,
toolcap,
punchitem,
- time_from_last_punch);
+ time_from_last_punch,
+ punchitem->wear);
if(result.did_punch && result.damage != 0)
{
// cheat detection.
// Get digging parameters
DigParams params = getDigParams(nodedef_manager->get(n).groups,
- &selected_item.getToolCapabilities(itemdef_manager));
+ &selected_item.getToolCapabilities(itemdef_manager),
+ selected_item.wear);
// If can't dig, try hand
if (!params.diggable) {
float time_from_last_punch =
playersao->resetTimeFromLastPunch();
- u16 wear = pointed_object->punch(dir, &toolcap, playersao,
- time_from_last_punch);
+ u32 wear = pointed_object->punch(dir, &toolcap, playersao,
+ time_from_last_punch, tool_item.wear);
// Callback may have changed item, so get it again
playersao->getWieldedItem(&selected_item);
// Get diggability and expected digging time
DigParams params = getDigParams(m_nodedef->get(n).groups,
- &selected_item.getToolCapabilities(m_itemdef));
+ &selected_item.getToolCapabilities(m_itemdef),
+ selected_item.wear);
// If can't dig, try hand
if (!params.diggable) {
params = getDigParams(m_nodedef->get(n).groups,
v3f dir = readParam<v3f>(L, 5, sao->getBasePosition() - puncher->getBasePosition());
dir.normalize();
- u16 wear = sao->punch(dir, &toolcap, puncher, time_from_last_punch);
+ u32 wear = sao->punch(dir, &toolcap, puncher, time_from_last_punch);
lua_pushnumber(L, wear);
return 1;
return 1;
}
-// get_dig_params(groups, tool_capabilities)
+// get_dig_params(groups, tool_capabilities[, wear])
int ModApiUtil::l_get_dig_params(lua_State *L)
{
NO_MAP_LOCK_REQUIRED;
ItemGroupList groups;
read_groups(L, 1, groups);
ToolCapabilities tp = read_tool_capabilities(L, 2);
- push_dig_params(L, getDigParams(groups, &tp));
+ if (lua_isnoneornil(L, 3)) {
+ push_dig_params(L, getDigParams(groups, &tp));
+ } else {
+ u16 wear = readParam<int>(L, 3);
+ push_dig_params(L, getDigParams(groups, &tp, wear));
+ }
return 1;
}
-// get_hit_params(groups, tool_capabilities[, time_from_last_punch])
+// get_hit_params(groups, tool_capabilities[, time_from_last_punch, [, wear]])
int ModApiUtil::l_get_hit_params(lua_State *L)
{
NO_MAP_LOCK_REQUIRED;
std::unordered_map<std::string, int> groups;
read_groups(L, 1, groups);
ToolCapabilities tp = read_tool_capabilities(L, 2);
- if(lua_isnoneornil(L, 3))
- push_hit_params(L, getHitParams(groups, &tp));
- else
- push_hit_params(L, getHitParams(groups, &tp, readParam<float>(L, 3)));
+ float time_from_last_punch = readParam<float>(L, 3, 1000000);
+ int wear = readParam<int>(L, 4, 0);
+ push_hit_params(L, getHitParams(groups, &tp,
+ time_from_last_punch, wear));
return 1;
}
// write_json(data[, styled])
static int l_write_json(lua_State *L);
- // get_dig_params(groups, tool_capabilities[, time_from_last_punch])
+ // get_dig_params(groups, tool_capabilities[, wear])
static int l_get_dig_params(lua_State *L);
- // get_hit_params(groups, tool_capabilities[, time_from_last_punch])
+ // get_hit_params(groups, tool_capabilities[, time_from_last_punch[, wear]])
static int l_get_hit_params(lua_State *L);
// check_password_entry(name, entry, password)
*result = os.str();
}
-u16 LuaEntitySAO::punch(v3f dir,
+u32 LuaEntitySAO::punch(v3f dir,
const ToolCapabilities *toolcap,
ServerActiveObject *puncher,
- float time_from_last_punch)
+ float time_from_last_punch,
+ u16 initial_wear)
{
if (!m_registered) {
// Delete unknown LuaEntities when punched
m_armor_groups,
toolcap,
&tool_item,
- time_from_last_punch);
+ time_from_last_punch,
+ initial_wear);
bool damage_handled = m_env->getScriptIface()->luaentity_Punch(m_id, puncher,
time_from_last_punch, toolcap, dir, result.did_punch ? result.damage : 0);
bool isStaticAllowed() const { return m_prop.static_save; }
bool shouldUnload() const { return true; }
void getStaticData(std::string *result) const;
- u16 punch(v3f dir, const ToolCapabilities *toolcap = nullptr,
+ u32 punch(v3f dir, const ToolCapabilities *toolcap = nullptr,
ServerActiveObject *puncher = nullptr,
- float time_from_last_punch = 1000000.0f);
+ float time_from_last_punch = 1000000.0f,
+ u16 initial_wear = 0);
void rightClick(ServerActiveObject *clicker);
void setPos(const v3f &pos);
void moveTo(v3f pos, bool continuous);
m_env->getGameDef()->SendMovePlayer(m_peer_id);
}
-u16 PlayerSAO::punch(v3f dir,
+u32 PlayerSAO::punch(v3f dir,
const ToolCapabilities *toolcap,
ServerActiveObject *puncher,
- float time_from_last_punch)
+ float time_from_last_punch,
+ u16 initial_wear)
{
if (!toolcap)
return 0;
s32 old_hp = getHP();
HitParams hitparams = getHitParams(m_armor_groups, toolcap,
- time_from_last_punch);
+ time_from_last_punch, initial_wear);
PlayerSAO *playersao = m_player->getPlayerSAO();
Interaction interface
*/
- u16 punch(v3f dir, const ToolCapabilities *toolcap, ServerActiveObject *puncher,
- float time_from_last_punch);
+ u32 punch(v3f dir, const ToolCapabilities *toolcap, ServerActiveObject *puncher,
+ float time_from_last_punch, u16 initial_wear = 0);
void rightClick(ServerActiveObject *clicker);
void setHP(s32 hp, const PlayerHPChangeReason &reason) override
{
virtual bool shouldUnload() const
{ return true; }
- // Returns tool wear
- virtual u16 punch(v3f dir,
+ // Returns added tool wear
+ virtual u32 punch(v3f dir,
const ToolCapabilities *toolcap = nullptr,
ServerActiveObject *puncher = nullptr,
- float time_from_last_punch = 1000000.0f)
+ float time_from_last_punch = 1000000.0f,
+ u16 initial_wear = 0)
{ return 0; }
virtual void rightClick(ServerActiveObject *clicker)
{}
}
}
+static u32 calculateResultWear(const u32 uses, const u16 initial_wear)
+{
+ if (uses == 0) {
+ // Trivial case: Infinite uses
+ return 0;
+ }
+ /* Finite uses. This is not trivial,
+ as the maximum wear is not neatly evenly divisible by
+ most possible uses numbers. For example, for 128
+ uses, the calculation of wear is trivial, as
+ 65536 / 128 uses = 512 wear,
+ so the tool will get 512 wear 128 times in its lifetime.
+ But for a number like 130, this does not work:
+ 65536 / 130 uses = 504.123... wear.
+ Since wear must be an integer, we will get
+ 504*130 = 65520, which would lead to the wrong number
+ of uses.
+
+ Instead, we partition the "wear range" into blocks:
+ A block represents a single use and can be
+ of two possible sizes: normal and oversized.
+ A normal block is equal to floor(65536 / uses).
+ An oversized block is a normal block plus 1.
+ Then we determine how many oversized and normal
+ blocks we need and finally, whether we add
+ the normal wear or the oversized wear.
+
+ Example for 130 uses:
+ * Normal wear = 504
+ * Number of normal blocks = 114
+ * Oversized wear = 505
+ * Number of oversized blocks = 16
+
+ If we add everything together, we get:
+ 114*504 + 16*505 = 65536
+ */
+ u32 result_wear;
+ u32 wear_normal = ((U16_MAX+1) / uses);
+ // Will be non-zero if its not evenly divisible
+ u16 blocks_oversize = (U16_MAX+1) % uses;
+ // Whether to add one extra wear point in case
+ // of oversized wear.
+ u16 wear_extra = 0;
+ if (blocks_oversize > 0) {
+ u16 blocks_normal = uses - blocks_oversize;
+ /* When the wear has reached this value, we
+ know that wear_normal has been applied
+ for blocks_normal times, therefore,
+ only oversized blocks remain.
+ This also implies the raw tool wear number
+ increases a bit faster after this point,
+ but this should be barely noticable by the
+ player.
+ */
+ u16 wear_extra_at = blocks_normal * wear_normal;
+ if (initial_wear >= wear_extra_at) {
+ wear_extra = 1;
+ }
+ }
+ result_wear = wear_normal + wear_extra;
+ return result_wear;
+}
+
DigParams getDigParams(const ItemGroupList &groups,
- const ToolCapabilities *tp)
+ const ToolCapabilities *tp,
+ const u16 initial_wear)
{
+
// Group dig_immediate defaults to fixed time and no wear
if (tp->groupcaps.find("dig_immediate") == tp->groupcaps.cend()) {
switch (itemgroup_get(groups, "dig_immediate")) {
// Values to be returned (with a bit of conversion)
bool result_diggable = false;
float result_time = 0.0;
- float result_wear = 0.0;
+ u32 result_wear = 0;
std::string result_main_group;
int level = itemgroup_get(groups, "level");
if (!result_diggable || time < result_time) {
result_time = time;
result_diggable = true;
- if (cap.uses != 0)
- result_wear = 1.0 / cap.uses / pow(3.0, leveldiff);
- else
- result_wear = 0;
+ // The actual number of uses increases
+ // exponentially with leveldiff.
+ // If the levels are equal, real_uses equals cap.uses.
+ u32 real_uses = cap.uses * pow(3.0, leveldiff);
+ real_uses = MYMIN(real_uses, U16_MAX);
+ result_wear = calculateResultWear(real_uses, initial_wear);
result_main_group = groupname;
}
}
- u16 wear_i = U16_MAX * result_wear;
- return DigParams(result_diggable, result_time, wear_i, result_main_group);
+ return DigParams(result_diggable, result_time, result_wear, result_main_group);
}
HitParams getHitParams(const ItemGroupList &armor_groups,
- const ToolCapabilities *tp, float time_from_last_punch)
+ const ToolCapabilities *tp, float time_from_last_punch,
+ u16 initial_wear)
{
s16 damage = 0;
float result_wear = 0.0f;
damage += damageGroup.second * punch_interval_multiplier * armor / 100.0;
}
- if (tp->punch_attack_uses > 0)
- result_wear = 1.0f / tp->punch_attack_uses * punch_interval_multiplier;
+ if (tp->punch_attack_uses > 0) {
+ result_wear = calculateResultWear(tp->punch_attack_uses, initial_wear);
+ result_wear *= punch_interval_multiplier;
+ }
- u16 wear_i = U16_MAX * result_wear;
+ u32 wear_i = (u32) result_wear;
return {damage, wear_i};
}
const ItemGroupList &armor_groups,
const ToolCapabilities *toolcap,
const ItemStack *punchitem,
- float time_from_last_punch
+ float time_from_last_punch,
+ u16 initial_wear
){
bool do_hit = true;
{
if(do_hit)
{
HitParams hitparams = getHitParams(armor_groups, toolcap,
- time_from_last_punch);
+ time_from_last_punch,
+ punchitem->wear);
result.did_punch = true;
result.wear = hitparams.wear;
result.damage = hitparams.hp;
// Digging time in seconds
float time;
// Caused wear
- u16 wear;
+ u32 wear; // u32 because wear could be 65536 (single-use tool)
std::string main_group;
- DigParams(bool a_diggable = false, float a_time = 0.0f, u16 a_wear = 0,
+ DigParams(bool a_diggable = false, float a_time = 0.0f, u32 a_wear = 0,
const std::string &a_main_group = ""):
diggable(a_diggable),
time(a_time),
};
DigParams getDigParams(const ItemGroupList &groups,
- const ToolCapabilities *tp);
+ const ToolCapabilities *tp,
+ const u16 initial_wear = 0);
struct HitParams
{
s16 hp;
- u16 wear;
+ // Caused wear
+ u32 wear; // u32 because wear could be 65536 (single-use weapon)
- HitParams(s16 hp_ = 0, u16 wear_ = 0):
+ HitParams(s16 hp_ = 0, u32 wear_ = 0):
hp(hp_),
wear(wear_)
{}
};
HitParams getHitParams(const ItemGroupList &armor_groups,
- const ToolCapabilities *tp, float time_from_last_punch);
+ const ToolCapabilities *tp, float time_from_last_punch,
+ u16 initial_wear = 0);
HitParams getHitParams(const ItemGroupList &armor_groups,
const ToolCapabilities *tp);
const ItemGroupList &armor_groups,
const ToolCapabilities *toolcap,
const ItemStack *punchitem,
- float time_from_last_punch
+ float time_from_last_punch,
+ u16 initial_wear = 0
);
f32 getToolRange(const ItemDefinition &def_selected, const ItemDefinition &def_hand);
projects / minetest.git / commitdiff
