mirror of
https://github.com/minetest-mods/player_monoids.git
synced 2025-06-14 15:20:41 +02:00
ee81c59f2c
This commit enhances the player_monoids library by adding branching support and an improved testing system to make sure it works, as proposed in #9 . These changes enable isolated player state management and improve library reliability. This PR focuses on implementing the branching proposal and adding automated tests.
637 lines
23 KiB
Lua
637 lines
23 KiB
Lua
-- monoids.lua
|
|
-- This file defines a set of testing chatcommands for the monoids system.
|
|
|
|
local speed = player_monoids.speed
|
|
local jump = player_monoids.jump
|
|
|
|
minetest.register_privilege("monoid_master", {
|
|
description = "Allows testing of player monoids.",
|
|
give_to_singleplayer = false,
|
|
give_to_admin = true,
|
|
})
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Helper: reset branches for both speed and jump
|
|
--------------------------------------------------------------------------------
|
|
local function reset_all_monoid_branches(player)
|
|
local p_name = player:get_player_name()
|
|
|
|
for _, monoid in ipairs({speed, jump}) do
|
|
if monoid and monoid.player_map and monoid.player_map[p_name] then
|
|
local pm = monoid.player_map[p_name]
|
|
local to_delete = {}
|
|
for bn, _ in pairs(pm.branches) do
|
|
table.insert(to_delete, bn)
|
|
end
|
|
for _, bn in ipairs(to_delete) do
|
|
local br = monoid:get_branch(bn)
|
|
if br then
|
|
br:reset(player)
|
|
br:delete(player)
|
|
end
|
|
end
|
|
monoid:get_branch("main")
|
|
monoid:checkout_branch(player, "main")
|
|
end
|
|
end
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- 1) Test Speed Add/Remove
|
|
--------------------------------------------------------------------------------
|
|
local function test_speed_add_remove(player)
|
|
local p_name = player:get_player_name()
|
|
reset_all_monoid_branches(player)
|
|
|
|
local before = speed:value(player)
|
|
local ch_id = speed:add_change(player, 10)
|
|
local after_add = speed:value(player)
|
|
|
|
if after_add == before then
|
|
minetest.chat_send_player(p_name, "[Add/Remove] FAIL: no speed change.")
|
|
else
|
|
minetest.chat_send_player(p_name, "[Add/Remove] PASS: speed " .. before .. " -> " .. after_add)
|
|
end
|
|
|
|
minetest.after(2, function()
|
|
local again = minetest.get_player_by_name(p_name)
|
|
if not again then return end
|
|
speed:del_change(again, ch_id)
|
|
local after_del = speed:value(again)
|
|
if math.abs(after_del - before) < 0.0001 then
|
|
minetest.chat_send_player(p_name, "[Add/Remove] PASS: speed returned to " .. before)
|
|
else
|
|
minetest.chat_send_player(p_name, "[Add/Remove] FAIL: final " .. after_del .. " != initial " .. before)
|
|
end
|
|
end)
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- 2) Test Branch Isolation
|
|
--------------------------------------------------------------------------------
|
|
local function test_branch_isolation(player)
|
|
local p_name = player:get_player_name()
|
|
reset_all_monoid_branches(player)
|
|
|
|
local init = speed:value(player)
|
|
speed:checkout_branch(player, "arena")
|
|
speed:add_change(player, 0.5, "arena_slowdown", "arena")
|
|
local arena_spd = speed:value(player)
|
|
if arena_spd >= init then
|
|
minetest.chat_send_player(p_name, "[BranchIsolation] FAIL: arena slowdown not effective.")
|
|
else
|
|
minetest.chat_send_player(p_name, "[BranchIsolation] PASS: arena slow " .. init .. " -> " .. arena_spd)
|
|
end
|
|
|
|
minetest.after(2, function()
|
|
speed:checkout_branch(player, "main")
|
|
speed:add_change(player, 2, "speed_boost")
|
|
local main_spd = speed:value(player)
|
|
if main_spd <= init then
|
|
minetest.chat_send_player(p_name, "[BranchIsolation] FAIL: main speedup not effective.")
|
|
else
|
|
minetest.chat_send_player(p_name, "[BranchIsolation] PASS: main speed " .. init .. " -> " .. main_spd)
|
|
end
|
|
end)
|
|
|
|
minetest.after(4, function()
|
|
speed:checkout_branch(player, "arena")
|
|
local arena2 = speed:value(player)
|
|
minetest.chat_send_player(p_name, "[BranchIsolation] re-check => " .. arena2)
|
|
end)
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- 3) Test Branch Concurrent
|
|
--------------------------------------------------------------------------------
|
|
local function test_branch_concurrent(player)
|
|
local p_name = player:get_player_name()
|
|
reset_all_monoid_branches(player)
|
|
|
|
local init = speed:value(player)
|
|
|
|
local arena_branch = speed:checkout_branch(player, "arena")
|
|
arena_branch:add_change(player, 0.5, "arena_slowdown")
|
|
local arena_spd = speed:value(player)
|
|
if arena_spd >= init then
|
|
minetest.chat_send_player(p_name, "[BranchConcurrent] FAIL: arena slowdown didn't reduce speed.")
|
|
else
|
|
minetest.chat_send_player(p_name, "[BranchConcurrent] PASS: arena from " .. init .. " -> " .. arena_spd)
|
|
end
|
|
|
|
minetest.after(2, function()
|
|
local mining_branch = speed:checkout_branch(player, "mining")
|
|
if not mining_branch then
|
|
minetest.chat_send_player(p_name, "[BranchConcurrent] FAIL: 'mining' branch could not be created.")
|
|
return
|
|
end
|
|
mining_branch:add_change(player, 0.3, "mining_slowdown")
|
|
|
|
local main_branch = speed:get_branch("main")
|
|
if not main_branch then
|
|
minetest.chat_send_player(p_name, "[BranchConcurrent] FAIL: 'main' branch doesn't exist?")
|
|
return
|
|
end
|
|
main_branch:add_change(player, 2, "main_speedup_concurrent")
|
|
|
|
local mining_spd = speed:value(player)
|
|
local main_spd = main_branch:value(player)
|
|
if mining_spd >= init then
|
|
minetest.chat_send_player(p_name, "[BranchConcurrent] FAIL: mining slowdown not effective.")
|
|
else
|
|
minetest.chat_send_player(p_name, "[BranchConcurrent] PASS: mining slow => " .. mining_spd)
|
|
end
|
|
if main_spd <= init then
|
|
minetest.chat_send_player(p_name, "[BranchConcurrent] FAIL: main concurrent speedup not effective.")
|
|
else
|
|
minetest.chat_send_player(p_name, "[BranchConcurrent] PASS: main speed => " .. main_spd)
|
|
end
|
|
end)
|
|
|
|
minetest.after(4, function()
|
|
local arena_b = speed:get_branch("arena")
|
|
if arena_b then
|
|
arena_b:reset(player)
|
|
speed:checkout_branch(player, "arena")
|
|
local reset_spd = speed:value(player)
|
|
minetest.chat_send_player(p_name, "[BranchConcurrent] arena reset => " .. reset_spd)
|
|
else
|
|
minetest.chat_send_player(p_name, "[BranchConcurrent] FAIL: 'arena' branch not found?")
|
|
end
|
|
end)
|
|
|
|
minetest.after(6, function()
|
|
speed:checkout_branch(player, "main")
|
|
local main_spd = speed:value(player)
|
|
minetest.chat_send_player(p_name, "[BranchConcurrent] final main => " .. main_spd)
|
|
end)
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- 4) Test OnChange ListenAll
|
|
--------------------------------------------------------------------------------
|
|
local function test_onchange_listen_all(player)
|
|
local p_name = player:get_player_name()
|
|
reset_all_monoid_branches(player)
|
|
|
|
local call_count = 0
|
|
speed.def.listen_to_all_changes = true
|
|
|
|
local old_on_change = speed.def.on_change
|
|
speed.def.on_change = function(old, new, plyr, branch)
|
|
call_count = call_count + 1
|
|
end
|
|
|
|
speed:add_change(player, 1, "active_change")
|
|
speed:add_change(player, 0.5, "arena_slowdown", "arena")
|
|
|
|
minetest.after(2, function()
|
|
speed.def.on_change = old_on_change
|
|
speed.def.listen_to_all_changes = false
|
|
if call_count == 0 then
|
|
minetest.chat_send_player(p_name, "[OnChangeAll] FAIL: on_change not triggered.")
|
|
else
|
|
minetest.chat_send_player(p_name, "[OnChangeAll] PASS: on_change called " .. call_count .. " times.")
|
|
end
|
|
end)
|
|
end
|
|
|
|
minetest.register_chatcommand("test_listen_all", {
|
|
description = "Test on_change across all branches.",
|
|
privs = {monoid_master = true},
|
|
func = function(p_name)
|
|
local player = minetest.get_player_by_name(p_name)
|
|
if player then
|
|
test_onchange_listen_all(player)
|
|
end
|
|
end,
|
|
})
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- 5) Test OnChange ListenActive
|
|
--------------------------------------------------------------------------------
|
|
local function test_onchange_listen_active(player)
|
|
local p_name = player:get_player_name()
|
|
reset_all_monoid_branches(player)
|
|
|
|
local call_count = 0
|
|
speed.def.listen_to_all_changes = false
|
|
|
|
local old_on_change = speed.def.on_change
|
|
speed.def.on_change = function(old, new, plyr, branch)
|
|
call_count = call_count + 1
|
|
end
|
|
|
|
speed:add_change(player, 1, "active_change")
|
|
speed:add_change(player, 0.5, "arena_slowdown", "arena")
|
|
|
|
minetest.after(2, function()
|
|
speed.def.on_change = old_on_change
|
|
speed.def.listen_to_all_changes = false
|
|
if call_count == 0 then
|
|
minetest.chat_send_player(p_name, "[OnChangeActive] FAIL: on_change not called.")
|
|
else
|
|
minetest.chat_send_player(p_name, "[OnChangeActive] PASS: on_change triggered " .. call_count .. " times.")
|
|
end
|
|
end)
|
|
end
|
|
|
|
minetest.register_chatcommand("test_listen_active", {
|
|
description = "Test on_change only in active branch.",
|
|
privs = {monoid_master = true},
|
|
func = function(p_name)
|
|
local player = minetest.get_player_by_name(p_name)
|
|
if player then
|
|
test_onchange_listen_active(player)
|
|
end
|
|
end,
|
|
})
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- 6) Test BranchName
|
|
--------------------------------------------------------------------------------
|
|
local function test_branch_name_check(player)
|
|
local p_name = player:get_player_name()
|
|
reset_all_monoid_branches(player)
|
|
|
|
speed:checkout_branch(player, "arena")
|
|
local branch = speed:get_branch("arena")
|
|
if not branch then
|
|
minetest.chat_send_player(p_name, "[BranchNameCheck] FAIL: get_branch('arena') is nil?")
|
|
return
|
|
end
|
|
local got = branch:get_name()
|
|
if got == "arena" then
|
|
minetest.chat_send_player(p_name, "[BranchNameCheck] PASS: got 'arena'")
|
|
else
|
|
minetest.chat_send_player(p_name, "[BranchNameCheck] FAIL: expected 'arena', got '" .. (got or "nil") .. "'")
|
|
end
|
|
end
|
|
|
|
minetest.register_chatcommand("test_branch_name", {
|
|
description = "Test branch:get_name() method.",
|
|
privs = {monoid_master = true},
|
|
func = function(p_name)
|
|
local player = minetest.get_player_by_name(p_name)
|
|
if player then
|
|
test_branch_name_check(player)
|
|
end
|
|
end,
|
|
})
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- 7) Test ActiveBranchGet
|
|
--------------------------------------------------------------------------------
|
|
local function test_active_branch_check(player)
|
|
local p_name = player:get_player_name()
|
|
reset_all_monoid_branches(player)
|
|
|
|
speed:checkout_branch(player, "arena")
|
|
local active = speed:get_active_branch(player)
|
|
local got = active and active:get_name() or "(nil)"
|
|
if got == "arena" then
|
|
minetest.chat_send_player(p_name, "[ActiveBranchGet] PASS: 'arena' active")
|
|
else
|
|
minetest.chat_send_player(p_name, "[ActiveBranchGet] FAIL: expected 'arena', got '" .. got .. "'")
|
|
end
|
|
end
|
|
|
|
minetest.register_chatcommand("test_active_branch", {
|
|
description = "Test monoid:get_active_branch.",
|
|
privs = {monoid_master = true},
|
|
func = function(p_name)
|
|
local player = minetest.get_player_by_name(p_name)
|
|
if player then
|
|
test_active_branch_check(player)
|
|
end
|
|
end,
|
|
})
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- 8) Test BranchDelete
|
|
--------------------------------------------------------------------------------
|
|
local function test_branch_delete_check(player)
|
|
local p_name = player:get_player_name()
|
|
reset_all_monoid_branches(player)
|
|
|
|
local main_branch = speed:get_branch("main")
|
|
local before_main = main_branch:value(player)
|
|
|
|
local del_branch = speed:checkout_branch(player, "delete_test")
|
|
del_branch:add_change(player, 0.2, "delete_test_slowdown")
|
|
local delete_spd = speed:value(player)
|
|
|
|
if delete_spd == before_main then
|
|
minetest.chat_send_player(p_name, "[BranchDelete] FAIL: no slowdown?")
|
|
else
|
|
minetest.chat_send_player(p_name, "[BranchDelete] PASS: speed from " .. before_main .. " to " .. delete_spd)
|
|
end
|
|
|
|
minetest.after(2, function()
|
|
del_branch:delete(player)
|
|
if speed.player_map[p_name].branches["delete_test"] then
|
|
minetest.chat_send_player(p_name, "[BranchDelete] FAIL: branch still exists.")
|
|
else
|
|
local active_b = speed.player_map[p_name].active_branch
|
|
local after_main = speed:value(player)
|
|
if active_b ~= "main" then
|
|
minetest.chat_send_player(p_name, "[BranchDelete] FAIL: active branch is " .. active_b)
|
|
elseif math.abs(after_main - before_main) > 0.0001 then
|
|
minetest.chat_send_player(p_name, "[BranchDelete] FAIL: main speed not restored.")
|
|
else
|
|
minetest.chat_send_player(p_name, "[BranchDelete] PASS: 'delete_test' gone, main restored.")
|
|
end
|
|
end
|
|
end)
|
|
end
|
|
|
|
minetest.register_chatcommand("test_branch_delete_monoids", {
|
|
description = "Runs a test on monoids branch deletion.",
|
|
privs = {monoid_master = true},
|
|
func = function(p_name)
|
|
local player = minetest.get_player_by_name(p_name)
|
|
if player then
|
|
test_branch_delete_check(player)
|
|
end
|
|
end,
|
|
})
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- 9) Test GetBranches
|
|
--------------------------------------------------------------------------------
|
|
local function test_get_branches(player)
|
|
local p_name = player:get_player_name()
|
|
reset_all_monoid_branches(player)
|
|
|
|
local br_a = speed:checkout_branch(player, "testA")
|
|
if br_a then
|
|
br_a:add_change(player, 2, "testA_boost")
|
|
else
|
|
minetest.chat_send_player(p_name, "[GetBranches] FAIL: unable to create 'testA'.")
|
|
end
|
|
|
|
local br_b = speed:new_branch(player, "testB")
|
|
if br_b then
|
|
br_b:add_change(player, 0.3, "testB_slow")
|
|
else
|
|
minetest.chat_send_player(p_name, "[GetBranches] FAIL: new_branch('testB') returned nil.")
|
|
end
|
|
|
|
local br_map = speed:get_branches(player)
|
|
if br_map["testA"] and br_map["testB"] then
|
|
minetest.chat_send_player(p_name, "[GetBranches] PASS: 'testA' and 'testB' found.")
|
|
else
|
|
minetest.chat_send_player(p_name, "[GetBranches] FAIL: missing 'testA' or 'testB' in get_branches.")
|
|
end
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- 10) Test on_branch_created / on_branch_deleted
|
|
--------------------------------------------------------------------------------
|
|
local function test_on_branch_create_delete(player)
|
|
local p_name = player:get_player_name()
|
|
reset_all_monoid_branches(player)
|
|
|
|
local created_count = 0
|
|
local deleted_count = 0
|
|
|
|
local old_on_branch_created = speed.def.on_branch_created
|
|
local old_on_branch_deleted = speed.def.on_branch_deleted
|
|
|
|
speed.def.on_branch_created = function(monoid, plyr, branch_name)
|
|
created_count = created_count + 1
|
|
end
|
|
|
|
speed.def.on_branch_deleted = function(monoid, plyr, branch_name)
|
|
deleted_count = deleted_count + 1
|
|
end
|
|
|
|
local new_branch = speed:checkout_branch(player, "my_new_branch")
|
|
if not new_branch then
|
|
minetest.chat_send_player(p_name, "[OnBranchCreateDelete] FAIL: checkout_branch returned nil.")
|
|
else
|
|
minetest.chat_send_player(p_name, "[OnBranchCreateDelete] Created 'my_new_branch'.")
|
|
end
|
|
|
|
local del_branch = speed:checkout_branch(player, "my_del_branch")
|
|
if not del_branch then
|
|
minetest.chat_send_player(p_name, "[OnBranchCreateDelete] FAIL: couldn't create 'my_del_branch'.")
|
|
else
|
|
minetest.chat_send_player(p_name, "[OnBranchCreateDelete] Created 'my_del_branch'. Deleting...")
|
|
del_branch:delete(player)
|
|
end
|
|
|
|
if created_count == 0 then
|
|
minetest.chat_send_player(p_name, "[OnBranchCreateDelete] FAIL: on_branch_created not called.")
|
|
else
|
|
minetest.chat_send_player(p_name, "[OnBranchCreateDelete] PASS: on_branch_created called " .. created_count .. " time(s).")
|
|
end
|
|
|
|
if deleted_count == 0 then
|
|
minetest.chat_send_player(p_name, "[OnBranchCreateDelete] FAIL: on_branch_deleted not called.")
|
|
else
|
|
minetest.chat_send_player(p_name, "[OnBranchCreateDelete] PASS: on_branch_deleted called " .. deleted_count .. " time(s).")
|
|
end
|
|
|
|
speed.def.on_branch_created = old_on_branch_created
|
|
speed.def.on_branch_deleted = old_on_branch_deleted
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- 11) Test monoid:new_branch
|
|
--------------------------------------------------------------------------------
|
|
local function test_new_branch_method(player)
|
|
local p_name = player:get_player_name()
|
|
reset_all_monoid_branches(player)
|
|
|
|
local init_speed = speed:value(player)
|
|
|
|
local custom_branch = speed:new_branch(player, "custom_new_branch")
|
|
if not custom_branch then
|
|
minetest.chat_send_player(p_name, "[NewBranchMethod] FAIL: new_branch returned nil")
|
|
return
|
|
end
|
|
custom_branch:add_change(player, 0.4, "custom_slow")
|
|
|
|
local after_new = speed:value(player)
|
|
if math.abs(after_new - init_speed) > 0.0001 then
|
|
minetest.chat_send_player(p_name, "[NewBranchMethod] FAIL: Speed changed even though new branch not active.")
|
|
else
|
|
minetest.chat_send_player(p_name, "[NewBranchMethod] PASS: Speed unchanged = " .. after_new)
|
|
end
|
|
|
|
speed:checkout_branch(player, "custom_new_branch")
|
|
local after_checkout = speed:value(player)
|
|
if after_checkout == init_speed then
|
|
minetest.chat_send_player(p_name, "[NewBranchMethod] FAIL: Speed not changed after activation.")
|
|
else
|
|
minetest.chat_send_player(p_name, "[NewBranchMethod] PASS: Speed changed from " .. init_speed .. " to " .. after_checkout)
|
|
end
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- 12) Test main branch cannot be deleted
|
|
--------------------------------------------------------------------------------
|
|
local function test_main_branch_cant_delete(player)
|
|
local p_name = player:get_player_name()
|
|
reset_all_monoid_branches(player)
|
|
|
|
local main_br = speed:get_branch("main")
|
|
if not main_br then
|
|
minetest.chat_send_player(p_name, "[MainBranchCantDelete] FAIL: main branch does not exist?")
|
|
return
|
|
end
|
|
|
|
main_br:delete(player)
|
|
local still_main = speed.player_map[p_name] and speed.player_map[p_name].branches["main"]
|
|
if still_main then
|
|
minetest.chat_send_player(p_name, "[MainBranchCantDelete] PASS: main not deleted.")
|
|
else
|
|
minetest.chat_send_player(p_name, "[MainBranchCantDelete] FAIL: main branch was deleted!")
|
|
end
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- 13) Test using speed + jump together in the same branch
|
|
--------------------------------------------------------------------------------
|
|
local function test_speed_and_jump_together(player)
|
|
local p_name = player:get_player_name()
|
|
|
|
if not jump then
|
|
minetest.chat_send_player(p_name, "[SpeedJumpTogether] FAIL: 'player_monoids.jump' not defined!")
|
|
return
|
|
end
|
|
|
|
reset_all_monoid_branches(player)
|
|
|
|
-- Grab initial speed + jump
|
|
local init_speed = speed:value(player)
|
|
local init_jump = jump:value(player)
|
|
|
|
-- Create or checkout a test branch that affects both
|
|
speed:checkout_branch(player, "double_test")
|
|
jump:checkout_branch(player, "double_test")
|
|
|
|
local sp_ch_id = speed:add_change(player, 2, "double_spd", "double_test")
|
|
local jp_ch_id = jump:add_change(player, 1.5, "double_jmp", "double_test")
|
|
|
|
local after_speed = speed:value(player)
|
|
local after_jump = jump:value(player)
|
|
|
|
local speed_changed = after_speed ~= init_speed
|
|
local jump_changed = after_jump ~= init_jump
|
|
|
|
if speed_changed and jump_changed then
|
|
minetest.chat_send_player(p_name, "[SpeedJumpTogether] PASS: Speed changed " .. init_speed .. "->" .. after_speed .. ", Jump changed " .. init_jump .. "->" .. after_jump)
|
|
else
|
|
minetest.chat_send_player(p_name, "[SpeedJumpTogether] FAIL: Speed changed=" .. tostring(speed_changed) .. ", Jump changed=" .. tostring(jump_changed))
|
|
end
|
|
|
|
-- Remove only speed change, see if jump remains.
|
|
speed:del_change(player, sp_ch_id, "double_test")
|
|
local sp2 = speed:value(player)
|
|
local jp2 = jump:value(player)
|
|
|
|
if math.abs(sp2 - init_speed) < 0.0001 and math.abs(jp2 - after_jump) < 0.0001 then
|
|
minetest.chat_send_player(p_name, "[SpeedJumpTogether] PASS: Speed reverted to " .. init_speed .. ", jump remains " .. jp2)
|
|
else
|
|
minetest.chat_send_player(p_name, "[SpeedJumpTogether] FAIL: partial revert mismatch. Speed=" .. sp2 .. ", jump=" .. jp2)
|
|
end
|
|
|
|
-- Remove jump change, confirm both are back to init
|
|
jump:del_change(player, jp_ch_id, "double_test")
|
|
local sp3 = speed:value(player)
|
|
local jp3 = jump:value(player)
|
|
|
|
if math.abs(sp3 - init_speed) < 0.0001 and math.abs(jp3 - init_jump) < 0.0001 then
|
|
minetest.chat_send_player(p_name, "[SpeedJumpTogether] PASS: both speed/jump back to init.")
|
|
else
|
|
minetest.chat_send_player(p_name, "[SpeedJumpTogether] FAIL: final mismatch. Speed=" .. sp3 .. ", jump=" .. jp3)
|
|
end
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- 14) Test monoid:value() with or without a branch param
|
|
-- to confirm it uses the active branch if omitted.
|
|
--------------------------------------------------------------------------------
|
|
local function test_value_api(player)
|
|
reset_all_monoid_branches(player)
|
|
local p_name = player:get_player_name()
|
|
|
|
local init_val = speed:value(player) -- active=main
|
|
|
|
-- new branch and add a slowdown
|
|
local br_test = speed:new_branch(player, "value_api_test")
|
|
br_test:add_change(player, 0.5, "slower")
|
|
-- the newly created branch is not active yet, so speed:value(player) remains init_val
|
|
local current_active_val = speed:value(player)
|
|
local named_branch_val = speed:value(player, "value_api_test")
|
|
|
|
if math.abs(current_active_val - init_val) < 0.0001 and named_branch_val < init_val then
|
|
minetest.chat_send_player(p_name, "[ValueAPI] PASS: value(player) used 'main'; value(player,'value_api_test') reflected slowdown.")
|
|
else
|
|
minetest.chat_send_player(p_name, "[ValueAPI] FAIL: mismatch. active=" .. current_active_val .. ", named=" .. named_branch_val .. ", init=" .. init_val)
|
|
return
|
|
end
|
|
|
|
-- now switch to that branch, confirm speed:value() uses that branch by default
|
|
speed:checkout_branch(player, "value_api_test")
|
|
local active_switched_val = speed:value(player)
|
|
if math.abs(active_switched_val - named_branch_val) < 0.0001 then
|
|
minetest.chat_send_player(p_name, "[ValueAPI] PASS: after checkout, value(player) matches 'value_api_test' branch value.")
|
|
else
|
|
minetest.chat_send_player(p_name, "[ValueAPI] FAIL: after checkout mismatch. got=" .. active_switched_val .. " vs named=" .. named_branch_val)
|
|
end
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- /test_monoids runs all tests in sequence
|
|
--------------------------------------------------------------------------------
|
|
|
|
local all_tests = {
|
|
{name = "AddRemove", func = test_speed_add_remove, delay = 2},
|
|
{name = "BranchIsolation", func = test_branch_isolation, delay = 2},
|
|
{name = "BranchConcurrent", func = test_branch_concurrent, delay = 4},
|
|
{name = "OnChangeAll", func = test_onchange_listen_all, delay = 2},
|
|
{name = "OnChangeActive", func = test_onchange_listen_active, delay = 2},
|
|
{name = "BranchNameCheck", func = test_branch_name_check, delay = 1},
|
|
{name = "ActiveBranchGet", func = test_active_branch_check, delay = 1},
|
|
{name = "BranchDelete", func = test_branch_delete_check, delay = 2},
|
|
{name = "GetBranches", func = test_get_branches, delay = 1},
|
|
{name = "OnBranchCreateDelete", func = test_on_branch_create_delete, delay = 2},
|
|
{name = "NewBranchMethod", func = test_new_branch_method, delay = 2},
|
|
{name = "MainBranchCantDelete", func = test_main_branch_cant_delete, delay = 1},
|
|
{name = "SpeedJumpTogether", func = test_speed_and_jump_together, delay = 3},
|
|
{name = "ValueAPI", func = test_value_api, delay = 2},
|
|
}
|
|
|
|
local function run_tests_sequentially(player, index)
|
|
local p_name = player:get_player_name()
|
|
if index > #all_tests then
|
|
minetest.chat_send_player(p_name, "All tests completed!")
|
|
return
|
|
end
|
|
|
|
local info = all_tests[index]
|
|
minetest.chat_send_player(p_name, "\n>>> " .. index .. "/" .. #all_tests .. " Running: " .. info.name .. "...")
|
|
info.func(player)
|
|
|
|
minetest.after(info.delay, function()
|
|
local again = minetest.get_player_by_name(p_name)
|
|
if not again then return end
|
|
run_tests_sequentially(again, index + 1)
|
|
end)
|
|
end
|
|
|
|
minetest.register_chatcommand("test_monoids", {
|
|
description = "Runs ALL monoid tests in sequence.",
|
|
privs = {monoid_master = true},
|
|
func = function(p_name)
|
|
local player = minetest.get_player_by_name(p_name)
|
|
if player then
|
|
minetest.chat_send_player(p_name, "Starting all monoid tests...")
|
|
run_tests_sequentially(player, 1)
|
|
end
|
|
end,
|
|
})
|