romanmir/MHR-Overlay
1
0
Fork 0
mirror of https://github.com/GreenComfyTea/MHR-Overlay.git synced 2026-01-23 20:08:05 -08:00
Code Issues Packages Projects Releases Wiki Activity

Refactoring

Browse Source
This commit is contained in:
GreenComfyTea
2023-08-21 17:29:57 +03:00
parent 1d31a86a3f
commit e67fbf923f
7 changed files with 172 additions and 1020 deletions
Download Patch File Download Diff File Expand all files Collapse all files

166
reframework/autorun/MHR_Overlay/Buffs/abnormal_statuses.lua
View File

@@ -75,6 +75,8 @@ this.list = {
muck = nil
};
local ailments_type_name = "ailments";
local frenzy_infected_duration = 121;
local player_quest_base_type_def = sdk.find_type_definition("snow.player.PlayerQuestBase");
@@ -140,17 +142,10 @@ local virus_timer_field = player_quest_base_type_def:get_field("_VirusTimer");
-- Frenzy
local virus_onset_timer_field = player_quest_base_type_def:get_field("_VirusOnsetTimer");
local player_data_type_def = sdk.find_type_definition("snow.player.PlayerData");
-- Frenzy Overcome
local virus_overcome_buff_timer_field = player_data_type_def:get_field("_VirusOvercomeBuffTimer");
local cache = {};
function this.update(player, player_data)
--local item_parameter = get_ref_item_parameter_method:call(singletons.player_manager);
--if item_parameter == nil then
@@ -167,94 +162,36 @@ function this.update(player, player_data)
this.update_muck(player);
this.update_frenzy_infection(player);
this.update_generic_timer("fireblight", player, fire_duration_timer);
this.update_generic_timer("waterblight", player, water_duration_timer);
this.update_generic_timer("iceblight", player, ice_duration_timer);
this.update_generic_timer("thunderblight", player, thunder_duration_timer);
this.update_generic_timer("dragonblight", player, dragon_duration_timer);
buffs.update_generic_buff(this.list, ailments_type_name, "fireblight", nil, nil, player, fire_duration_timer);
this.update_generic_timer("blastblight", player, bomb_duration_timer);
this.update_generic_timer("hellfireblight", player, oni_bomb_duration_timer);
this.update_generic_timer("bloodblight", player, mystery_debuff_timer);
buffs.update_generic_buff(this.list, ailments_type_name, "fireblight", nil, nil, player, fire_duration_timer);
buffs.update_generic_buff(this.list, ailments_type_name, "waterblight", nil, nil, player, water_duration_timer);
buffs.update_generic_buff(this.list, ailments_type_name, "iceblight", nil, nil, player, ice_duration_timer);
buffs.update_generic_buff(this.list, ailments_type_name, "thunderblight", nil, nil, player, thunder_duration_timer);
buffs.update_generic_buff(this.list, ailments_type_name, "dragonblight", nil, nil, player, dragon_duration_timer);
this.update_generic_timer("stun", player, stun_duration_timer);
this.update_generic_timer("paralysis", player, paralyze_duration_timer);
this.update_generic_timer("sleep", player, sleep_duration_timer);
buffs.update_generic_buff(this.list, ailments_type_name, "blastblight", nil, nil, player, bomb_duration_timer);
buffs.update_generic_buff(this.list, ailments_type_name, "hellfireblight", nil, nil, player, oni_bomb_duration_timer);
buffs.update_generic_buff(this.list, ailments_type_name, "bloodblight", nil, nil, player, mystery_debuff_timer);
buffs.update_generic_buff(this.list, ailments_type_name, "stun", nil, nil, player, stun_duration_timer);
buffs.update_generic_buff(this.list, ailments_type_name, "paralysis", nil, nil, player, paralyze_duration_timer);
buffs.update_generic_buff(this.list, ailments_type_name, "sleep", nil, nil, player, sleep_duration_timer);
this.update_generic_timer("defense_down", player, defense_down_duration_timer);
this.update_generic_timer("resistance_down", player, resistance_down_duration_timer);
buffs.update_generic_buff(this.list, ailments_type_name, "defense_down", nil, nil, player, defense_down_duration_timer);
buffs.update_generic_buff(this.list, ailments_type_name, "resistance_down", nil, nil, player, resistance_down_duration_timer);
this.update_generic_timer("tremor", player, quake_duration_timer);
this.update_generic_timer("roar", player, ear_duration_timer);
this.update_generic_timer("webbed", player, beto_duration_timer);
this.update_generic_timer("stench", player, stink_duration_timer);
this.update_generic_timer("leeched", player, blooding_enemy_timer, true);
this.update_generic_timer("bleeding", player, bleeding_debuff_timer);
this.update_generic_timer("frenzy", player, virus_onset_timer_field);
this.update_generic_timer("frenzy_overcome", player_data, virus_overcome_buff_timer_field);
buffs.update_generic_buff(this.list, ailments_type_name, "tremor", nil, nil, player, quake_duration_timer);
buffs.update_generic_buff(this.list, ailments_type_name, "roar", nil, nil, player, ear_duration_timer);
buffs.update_generic_buff(this.list, ailments_type_name, "webbed", nil, nil, player, beto_duration_timer);
buffs.update_generic_buff(this.list, ailments_type_name, "stench", nil, nil, player, stink_duration_timer);
buffs.update_generic_buff(this.list, ailments_type_name, "leeched", nil, nil, player, blooding_enemy_timer, nil, nil, true);
buffs.update_generic_buff(this.list, ailments_type_name, "bleeding", nil, nil, player, bleeding_debuff_timer);
buffs.update_generic_buff(this.list, ailments_type_name, "frenzy", nil, nil, player, virus_onset_timer_field);
buffs.update_generic_buff(this.list, ailments_type_name, "frenzy_overcome", nil, nil, player_data, virus_overcome_buff_timer_field);
this.update_generic_boolean_value_method("engulfed", player, get_is_vacuum_damage_method);
this.update_generic_boolean_value_method("frostblight", player, get_is_frozen_damage_method);
end
function this.update_generic_timer(debuff_key, timer_owner, timer_field, is_infinite)
if is_infinite == nil then is_infinite = false; end
local timer = timer_field:get_data(timer_owner);
if timer == nil then
error_handler.report("abnormal_statuses.update_generic_timer", string.format("Failed to access Data: %s_timer", debuff_key));
return;
end
if utils.number.is_equal(timer, 0) then
this.list[debuff_key] = nil;
return;
end
if is_infinite then
timer = nil;
else
timer = timer / 60;
end
this.update_generic(debuff_key, timer);
end
function this.update_generic_boolean_value_method(debuff_key, value_owner, value_method)
local value = value_method:call(value_owner);
if value == nil then
error_handler.report("abnormal_statuses.update_generic_boolean_value_method", string.format("Failed to access Data: %s_value", debuff_key));
return;
end
if not value then
this.list[debuff_key] = nil;
return;
end
this.update_generic(debuff_key, nil);
end
function this.update_bubbleblight(player)
local bubble_Type = bubble_type_field:get_data(player);
if bubble_Type == nil then
error_handler.report("abnormal_statuses.update_bubbleblight", "Failed to access Data: bubble_Type");
return;
end
if bubble_Type == 0 then
this.list.minor_bubbleblight = nil;
this.list.major_bubbleblight = nil;
return;
end
if bubble_Type == 1 then
this.update_generic_timer("minor_bubbleblight", player, bubble_damage_timer);
this.list.major_bubbleblight = nil;
else
this.update_generic_timer("major_bubbleblight", player, bubble_damage_timer);
this.list.minor_bubbleblight = nil;
end
buffs.update_generic_buff(this.list, ailments_type_name, "engulfed", player, get_is_vacuum_damage_method);
buffs.update_generic_buff(this.list, ailments_type_name, "frostblight", player, get_is_frozen_damage_method);
end
function this.update_poison(player)
@@ -271,14 +208,36 @@ function this.update_poison(player)
end
if poison_level == 1 then
this.update_generic_timer("poison", player, poison_duration_timer);
buffs.update_generic_buff(this.list, ailments_type_name, "poison", player, poison_duration_timer);
this.list.deadly_poison = nil;
else
this.update_generic_timer("deadly_poison", player, poison_duration_timer);
buffs.update_generic_buff(this.list, ailments_type_name, "deadly_poison", player, poison_duration_timer);
this.list.poison = nil;
end
end
function this.update_bubbleblight(player)
local bubble_type = bubble_type_field:get_data(player);
if bubble_type == nil then
error_handler.report("abnormal_statuses.update_bubbleblight", "Failed to access Data: bubble_Type");
return;
end
if bubble_type == 0 then
this.list.minor_bubbleblight = nil;
this.list.major_bubbleblight = nil;
return;
end
if bubble_type == 1 then
buffs.update_generic_buff(this.list, ailments_type_name, "minor_bubbleblight", player, bubble_damage_timer);
this.list.major_bubbleblight = nil;
else
buffs.update_generic_buff(this.list, ailments_type_name, "major_bubbleblight", player, bubble_damage_timer);
this.list.minor_bubbleblight = nil;
end
end
function this.update_muck(player)
local is_mud_damage = get_is_mud_damage_method:call(player);
if is_mud_damage == nil then
@@ -297,7 +256,7 @@ function this.update_muck(player)
return;
end
this.update_generic("muck", nil);
buffs.update_generic(ailments_type_name, "muck");
end
function this.update_frenzy_infection(player)
@@ -313,31 +272,14 @@ function this.update_frenzy_infection(player)
return;
end
if virus_accumulator_value == 0 and utils.number.is_equal(virus_timer, 0)then
if virus_accumulator_value == 0 and utils.number.is_equal(virus_timer, 0) then
this.list.frenzy_infection = nil;
return;
end
local timer = frenzy_infected_duration - (virus_accumulator_value + virus_timer / 60);
this.update_generic("frenzy_infection", timer, frenzy_infected_duration);
end
function this.update_generic(debuff_key, timer, duration)
duration = duration or timer;
local debuff = this.list[debuff_key];
if debuff == nil then
local name = language.current_language.ailments[debuff_key];
if name == nil then
name = debuff_key;
end
debuff = buffs.new(buffs.types.debuff, debuff_key, name, 1, duration);
this.list[debuff_key] = debuff;
elseif timer ~= nil then
buffs.update_timer(debuff, timer);
end
buffs.update_generic(this.list, ailments_type_name, "frenzy_infection", 1, timer, frenzy_infected_duration);
end
function this.init_names()

158
reframework/autorun/MHR_Overlay/Buffs/consumables.lua
View File

@@ -55,6 +55,8 @@ this.list = {
gourmet_fish = nil,
};
local consumables_type_name = "consumables";
local player_manager_type_def = sdk.find_type_definition("snow.player.PlayerManager");
local get_player_data_method = player_manager_type_def:get_method("get_PlayerData");
local get_ref_item_parameter_method = player_manager_type_def:get_method("get_RefItemParameter");
@@ -106,69 +108,42 @@ function this.update(player_data)
this.update_demondrug(player_data, item_parameter);
this.update_armorskin(player_data, item_parameter);
this.update_gourmet_fish(player_data, item_parameter);
this.update_generic("might_seed", player_data, item_parameter,
atk_up_buff_second_field, atk_up_buff_second_timer_field, might_seed_timer_field);
buffs.update_generic_buff(this.list, consumables_type_name, "might_seed",
player_data, atk_up_buff_second_field,
player_data, atk_up_buff_second_timer_field,
item_parameter, might_seed_timer_field);
this.update_generic("adamant_seed", player_data, item_parameter,
def_up_buff_second_field, def_up_buff_second_timer_field, adamant_seed_timer_field);
buffs.update_generic_buff(this.list, consumables_type_name, "adamant_seed",
player_data, def_up_buff_second_field,
player_data, def_up_buff_second_timer_field,
item_parameter, adamant_seed_timer_field);
this.update_generic("demon_powder", player_data, item_parameter,
atk_up_item_second_field, atk_up_item_second_timer_field, demondrug_powder_timer_field);
buffs.update_generic_buff(this.list, consumables_type_name, "demon_powder",
player_data, atk_up_item_second_field,
player_data, atk_up_item_second_timer_field,
item_parameter, demondrug_powder_timer_field);
this.update_generic("hardshell_powder", player_data, item_parameter,
def_up_item_second_field, def_up_item_second_timer_field, armorskin_powder_timer_field);
buffs.update_generic_buff(this.list, consumables_type_name, "hardshell_powder",
player_data, def_up_item_second_field,
player_data, def_up_item_second_timer_field,
item_parameter, armorskin_powder_timer_field);
buffs.update_generic_buff(this.list, consumables_type_name, "immunizer",
nil, nil,
player_data, vitalizer_timer_field,
item_parameter, vitalizer_timer_const_field);
this.update_generic("immunizer", player_data, item_parameter,
nil, vitalizer_timer_field, vitalizer_timer_const_field);
buffs.update_generic_buff(this.list, consumables_type_name, "immunizer",
nil, nil,
player_data, stamina_up_buff_second_timer_field,
item_parameter, stamina_up_buff_second_field);
this.update_generic("dash_juice", player_data, item_parameter,
nil, stamina_up_buff_second_timer_field, stamina_up_buff_second_field);
end
function this.update_generic(consumable_key, player_data, item_parameter, value_field, timer_field, timer_const_value_field)
if value_field ~= nil then
local value = value_field:get_data(player_data);
if value == nil then
error_handler.report("consumables.update_generic", string.format("Failed to access Data: %s_value", consumable_key));
return;
end
if value == 0 then
this.list[consumable_key] = nil;
return;
end
end
local timer = timer_field:get_data(player_data);
if timer == nil then
error_handler.report("consumables.update_generic", string.format("Failed to access Data: %s_timer", consumable_key));
return;
end
if value_field == nil and utils.number.is_equal(timer, 0)then
this.list[consumable_key] = nil;
return;
end
local consumable = this.list[consumable_key];
if consumable == nil then
local timer_const_value = timer_const_value_field:get_data(item_parameter);
if timer_const_value == nil then
error_handler.report("consumables.update_generic", string.format("Failed to access Data: %s_timer_const_value", consumable_key));
return;
end
local name = language.current_language.consumables[consumable_key];
consumable = buffs.new(buffs.types.consumable, consumable_key, name, 1, timer_const_value);
this.list[consumable_key] = consumable;
else
buffs.update_timer(consumable, timer / 60);
end
buffs.update_generic_buff(this.list, consumables_type_name, "gourmet_fish",
nil, nil,
player_data, fish_regene_enable_field,
nil, nil);
end
function this.update_demondrug(player_data, item_parameter)
@@ -195,27 +170,14 @@ function this.update_demondrug(player_data, item_parameter)
error_handler.report("consumables.update_demondrug", "Failed to access Data: mega_demondrug_const_value");
return;
end
if demondrug_value == demondrug_const_value then
local buff = this.list.demondrug;
if buff ~= nil and buff.value == demondrug_value then
return;
end
local name = language.current_language.consumables.demondrug;
this.list.demondrug = buffs.new(buffs.types.consumable, "demondrug", name);
buffs.update_generic(this.list, consumables_type_name, "demondrug");
this.list.mega_demondrug = nil;
elseif demondrug_value == mega_demondrug_const_value then
local buff = this.list.mega_demondrug;
if buff ~= nil and buff.value == demondrug_value then
return;
end
local name = language.current_language.consumables.mega_demondrug;
buffs.update_generic(this.list, consumables_type_name, "mega_demondrug");
this.list.demondrug = nil;
this.list.mega_demondrug = buffs.new(buffs.types.consumable, "mega_demondrug", name);
end
end
@@ -245,56 +207,12 @@ function this.update_armorskin(player_data, item_parameter)
end
if armorskin_value == armorskin_const_value then
local buff = this.list.armorskin;
if buff ~= nil and buff.value == armorskin_value then
return;
end
local name = language.current_language.consumables.armorskin;
this.list.armorskin = buffs.new(buffs.types.consumable, "armorskin", name);
buffs.update_generic(this.list, consumables_type_name, "armorskin");
this.list.mega_armorskin = nil;
elseif armorskin_value == mega_armorskin_const_value then
local buff = this.list.mega_armorskin;
if buff ~= nil and buff.value == armorskin_value then
return;
end
local name = language.current_language.consumables.mega_armorskin;
buffs.update_generic(this.list, consumables_type_name, "mega_armorskin");
this.list.armorskin = nil;
this.list.mega_armorskin = buffs.new(buffs.types.consumable, "mega_armorskin", name);
end
end
function this.update_gourmet_fish(player_data, item_parameter)
local gourmet_fish_timer = fish_regene_enable_field:get_data(player_data);
if gourmet_fish_timer == nil then
error_handler.report("consumables.update_gourmet_fish", "Failed to access Data: gourmet_fish_timer");
return;
end
if utils.number.is_equal(gourmet_fish_timer, 0) then
this.list.gourmet_fish = nil;
return;
end
local buff = this.list.gourmet_fish;
if buff == nil then
--local gourmet_fish_timer_const_value = stamina_up_buff_second_field:get_data(item_parameter);
--if gourmet_fish_timer_const_value == nil then
-- error_handler.report("consumables.update_gourmet_fish", "Failed to access Data: gourmet_fish_timer_const_value");
-- return;
--end
local name = language.current_language.consumables.gourmet_fish;
buff = buffs.new(buffs.types.consumable, "gourmet_fish", name, 1, gourmet_fish_timer);
this.list.gourmet_fish = buff;
else
buffs.update_timer(buff, gourmet_fish_timer / 60);
end
end

217
reframework/autorun/MHR_Overlay/Buffs/dangos.lua
View File

@@ -47,6 +47,8 @@ this.list = {
};
this.is_dango_adrenaline_active = false;
local dangos_type_name = "dangos";
local dango_defender_minimal_value = 200;
local player_manager_type_def = sdk.find_type_definition("snow.player.PlayerManager");
@@ -72,229 +74,18 @@ function this.update(player, player_data)
return;
end
this.update_generic_number_value_field("dango_defender", player_data, kitchen_skill_048_field, nil, true, dango_defender_minimal_value);
buffs.update_generic_buff(this.list, dangos_type_name, "dango_defender", player_data, kitchen_skill_048_field, nil, nil, nil, nil, true, dango_defender_minimal_value);
this.update_dango_adrenaline();
end
function this.update_generic_timer(dango_key, timer_owner, timer_field, is_infinite)
if is_infinite == nil then is_infinite = false; end
local timer = nil;
if timer_field ~= nil then
timer = timer_field:get_data(timer_owner);
if timer == nil then
error_handler.report("dangos.update_generic_timer", string.format("Failed to access Data: %s_timer", dango_key));
return;
end
if utils.number.is_equal(timer, 0) then
this.list[dango_key] = nil;
return;
end
if is_infinite then
timer = nil;
else
timer = timer / 60;
end
end
this.update_generic(dango_key, 1, timer);
end
function this.update_generic_number_value_field(dango_key, timer_owner, value_field, timer_field, is_infinite, minimal_value)
if minimal_value == nil then minimal_value = 1; end
if is_infinite == nil then is_infinite = false; end
local level = 1;
if value_field ~= nil then
local value = value_field:get_data(timer_owner);
if value == nil then
error_handler.report("dangos.update_generic_number_value_field", string.format("Failed to access Data: %s_value", dango_key));
return;
end
if value < minimal_value then
this.list[dango_key] = nil;
return;
end
end
local timer = nil;
if timer_field ~= nil then
timer = timer_field:get_data(timer_owner);
if timer == nil then
error_handler.report("dangos.update_generic_number_value_field", string.format("Failed to access Data: %s_timer", dango_key));
return;
end
if value_field == nil and utils.number.is_equal(timer, 0) then
this.list[dango_key] = nil;
return;
end
if is_infinite then
timer = nil;
else
timer = timer / 60;
end
end
this.update_generic(dango_key, level, timer);
end
function this.update_generic_boolean_value_field(dango_key, timer_owner, value_field, timer_field, is_infinite, minimal_value)
if minimal_value == nil then minimal_value = true; end
if is_infinite == nil then is_infinite = false; end
if value_field ~= nil then
local value = value_field:get_data(timer_owner);
if value == nil then
error_handler.report("dangos.update_generic_boolean_value_field", string.format("Failed to access Data: %s_value", dango_key));
return;
end
if value < minimal_value then
this.list[dango_key] = nil;
return;
end
end
local timer = nil;
if timer_field ~= nil then
timer = timer_field:get_data(timer_owner);
if timer == nil then
error_handler.report("dangos.update_generic_boolean_value_field", string.format("Failed to access Data: %s_timer", dango_key));
return;
end
if value_field == nil and utils.number.is_equal(timer, 0) then
this.list[dango_key] = nil;
return;
end
if is_infinite then
timer = nil;
else
timer = timer / 60;
end
end
this.update_generic(dango_key, 1, timer);
end
function this.update_generic_number_value_method(dango_key, timer_owner, value_method, timer_field, is_infinite, minimal_value)
if minimal_value == nil then minimal_value = 1; end
if is_infinite == nil then is_infinite = false; end
local level = 1;
if value_method ~= nil then
local value = value_method:call(timer_owner);
if value == nil then
error_handler.report("dangos.update_generic_number_value_method", string.format("Failed to access Data: %s_value", dango_key));
return;
end
if value < minimal_value then
this.list[dango_key] = nil;
return;
end
end
local timer = nil;
if timer_field ~= nil then
timer = timer_field:get_data(timer_owner);
if timer == nil then
error_handler.report("dangos.update_generic_number_value_method", string.format("Failed to access Data: %s_timer", dango_key));
return;
end
if value_method == nil and utils.number.is_equal(timer, 0) then
this.list[dango_key] = nil;
return;
end
if is_infinite then
timer = nil;
else
timer = timer / 60;
end
end
this.update_generic(dango_key, level, timer);
end
function this.update_generic_boolean_value_method(dango_key, timer_owner, value_method, timer_field, is_infinite, minimal_value)
if minimal_value == nil then minimal_value = true; end
if is_infinite == nil then is_infinite = false; end
if value_method ~= nil then
local value = value_method:call(timer_owner);
if value == nil then
error_handler.report("dangos.update_generic_boolean_value_method", string.format("Failed to access Data: %s_value", dango_key));
return;
end
if value ~= minimal_value then
this.list[dango_key] = nil;
return;
end
end
local timer = nil;
if timer_field ~= nil then
timer = timer_field:get_data(timer_owner);
if timer == nil then
error_handler.report("dangos.update_generic_boolean_value_method", string.format("Failed to access Data: %s_timer", dango_key));
return;
end
if value_method == nil and utils.number.is_equal(timer, 0) then
this.list[dango_key] = nil;
return;
end
if is_infinite then
timer = nil;
else
timer = timer / 60;
end
end
this.update_generic(dango_key, 1, timer);
end
function this.update_generic(dango_key, level, timer, duration)
duration = duration or timer;
local dango = this.list[dango_key];
if dango == nil then
local name = language.current_language.dangos[dango_key];
dango = buffs.new(buffs.types.dango, dango_key, name, level, duration);
this.list[dango_key] = dango;
else
dango.level = level;
if timer ~= nil then
buffs.update_timer(dango, timer);
end
end
end
function this.update_dango_adrenaline()
if not this.is_dango_adrenaline_active then
this.list.dango_adrenaline = nil;
return;
end
this.update_generic("dango_adrenaline", 1);
buffs.update_generic(this.list, dangos_type_name, "dango_adrenaline");
end
function this.init_names()

15
reframework/autorun/MHR_Overlay/Buffs/endemic_life_buffs.lua
View File

@@ -81,12 +81,15 @@ function this.update(player, player_data)
this.update_ruby_and_gold_wirebugs(player, player_data);
end
function this.update_generic_timer(endemic_life_buff_key, timer_owner, timer_field, is_infinite)
if is_infinite == nil then is_infinite = false; end
function this.update_generic_timer(endemic_life_buff_key, timer_owner, timer_holder, is_infinite)
local timer = nil;
if timer_field ~= nil then
timer = timer_field:get_data(timer_owner);
if timer_holder ~= nil then
if utils.type.is_REField then
timer = timer_holder:get_data(timer_owner);
else
timer = timer_holder:call(timer_owner);
end
if timer == nil then
error_handler.report("endemic_life_buffs.update_generic_timer", string.format("Failed to access Data: %s_timer", endemic_life_buff_key));
return;
@@ -123,7 +126,7 @@ function this.update_generic(endemic_life_buff_key, level, timer, duration)
return;
end
endemic_life_buff = buffs.new(buffs.types.endemic_life_buff, endemic_life_buff_key, name, level, duration);
endemic_life_buff = buffs.new("endemic_life_buffs", endemic_life_buff_key, name, level, duration);
this.list[endemic_life_buff_key] = endemic_life_buff;
else
endemic_life_buff.level = level;

4
reframework/autorun/MHR_Overlay/Buffs/melody_effects.lua
View File

@@ -138,7 +138,7 @@ function this.update(master_player)
goto continue;
end
this.update_melody_effect(i+1, music_data);
this.update_melody_effect(i + 1, music_data);
::continue::
end
end
@@ -160,7 +160,7 @@ function this.update_melody_effect(lua_index, melody_data)
local melody_effect_key = melody_effect_keys[lua_index];
local name = language.current_language.melody_effects[melody_effect_key];
melody_effect = buffs.new(buffs.types.melody_effect, melody_effect_key, name, 1, melody_timer / 60);
melody_effect = buffs.new("melody_effects", melody_effect_key, name, 1, melody_timer / 60);
this.list[lua_index] = melody_effect;
else
buffs.update_timer(melody_effect, melody_timer / 60);

220
reframework/autorun/MHR_Overlay/Buffs/otomo_moves.lua
View File

@@ -51,6 +51,7 @@ this.list = {
go_fight_win = nil
};
local otomo_moves_type_name = "otomo_moves";
local player_manager_type_def = sdk.find_type_definition("snow.player.PlayerManager");
local get_player_data_method = player_manager_type_def:get_method("get_PlayerData");
@@ -64,222 +65,9 @@ local kijin_otomo_timer_field = player_data_type_def:get_field("_KijinOtomoTimer
local runhigh_otomo_timer_field = player_data_type_def:get_field("_RunhighOtomoTimer");
function this.update(player_data)
this.update_generic_timer("rousing_roar", player_data, beast_roar_otomo_timer_field);
this.update_generic_timer("power_drum", player_data, kijin_otomo_timer_field);
this.update_generic_timer("go_fight_win", player_data, runhigh_otomo_timer_field);
end
function this.update_generic_timer(otomo_move_key, timer_owner, timer_field, is_infinite)
if is_infinite == nil then is_infinite = false; end
local timer = nil;
if timer_field ~= nil then
timer = timer_field:get_data(timer_owner);
if timer == nil then
error_handler.report("otomo_moves.update_generic_timer", string.format("Failed to access Data: %s_timer", otomo_move_key));
return;
end
if utils.number.is_equal(timer, 0) then
this.list[otomo_move_key] = nil;
return;
end
if is_infinite then
timer = nil;
else
timer = timer / 60;
end
end
this.update_generic(otomo_move_key, 1, timer);
end
function this.update_generic_number_value_field(otomo_move_key, timer_owner, value_field, timer_field, is_infinite, minimal_value)
if minimal_value == nil then minimal_value = 1; end
if is_infinite == nil then is_infinite = false; end
local level = 1;
if value_field ~= nil then
local value = value_field:get_data(timer_owner);
if value == nil then
error_handler.report("otomo_moves.update_generic_number_value_field", string.format("Failed to access Data: %s_value", otomo_move_key));
return;
end
if value < minimal_value then
this.list[otomo_move_key] = nil;
return;
end
end
local timer = nil;
if timer_field ~= nil then
timer = timer_field:get_data(timer_owner);
if timer == nil then
error_handler.report("otomo_moves.update_generic_number_value_field", string.format("Failed to access Data: %s_timer", otomo_move_key));
return;
end
if value_field == nil and utils.number.is_equal(timer, 0) then
this.list[otomo_move_key] = nil;
return;
end
if is_infinite then
timer = nil;
else
timer = timer / 60;
end
end
this.update_generic(otomo_move_key, level, timer);
end
function this.update_generic_boolean_value_field(otomo_move_key, timer_owner, value_field, timer_field, is_infinite, minimal_value)
if minimal_value == nil then minimal_value = true; end
if is_infinite == nil then is_infinite = false; end
if value_field ~= nil then
local value = value_field:get_data(timer_owner);
if value == nil then
error_handler.report("otomo_moves.update_generic_boolean_value_field", string.format("Failed to access Data: %s_value", otomo_move_key));
return;
end
if value < minimal_value then
this.list[otomo_move_key] = nil;
return;
end
end
local timer = nil;
if timer_field ~= nil then
timer = timer_field:get_data(timer_owner);
if timer == nil then
error_handler.report("otomo_moves.update_generic_boolean_value_field", string.format("Failed to access Data: %s_timer", otomo_move_key));
return;
end
if value_field == nil and utils.number.is_equal(timer, 0) then
this.list[otomo_move_key] = nil;
return;
end
if is_infinite then
timer = nil;
else
timer = timer / 60;
end
end
this.update_generic(otomo_move_key, 1, timer);
end
function this.update_generic_number_value_method(otomo_move_key, timer_owner, value_method, timer_field, is_infinite, minimal_value)
if minimal_value == nil then minimal_value = 1; end
if is_infinite == nil then is_infinite = false; end
local level = 1;
if value_method ~= nil then
local value = value_method:call(timer_owner);
if value == nil then
error_handler.report("otomo_moves.update_generic_number_value_method", string.format("Failed to access Data: %s_value", otomo_move_key));
return;
end
if value < minimal_value then
this.list[otomo_move_key] = nil;
return;
end
end
local timer = nil;
if timer_field ~= nil then
timer = timer_field:get_data(timer_owner);
if timer == nil then
error_handler.report("otomo_moves.update_generic_number_value_method", string.format("Failed to access Data: %s_timer", otomo_move_key));
return;
end
if value_method == nil and utils.number.is_equal(timer, 0) then
this.list[otomo_move_key] = nil;
return;
end
if is_infinite then
timer = nil;
else
timer = timer / 60;
end
end
this.update_generic(otomo_move_key, level, timer);
end
function this.update_generic_boolean_value_method(otomo_move_key, timer_owner, value_method, timer_field, is_infinite, minimal_value)
if minimal_value == nil then minimal_value = true; end
if is_infinite == nil then is_infinite = false; end
if value_method ~= nil then
local value = value_method:call(timer_owner);
if value == nil then
error_handler.report("otomo_moves.update_generic_boolean_value_method", string.format("Failed to access Data: %s_value", otomo_move_key));
return;
end
if value ~= minimal_value then
this.list[otomo_move_key] = nil;
return;
end
end
local timer = nil;
if timer_field ~= nil then
timer = timer_field:get_data(timer_owner);
if timer == nil then
error_handler.report("otomo_moves.update_generic_boolean_value_method", string.format("Failed to access Data: %s_timer", otomo_move_key));
return;
end
if value_method == nil and utils.number.is_equal(timer, 0) then
this.list[otomo_move_key] = nil;
return;
end
if is_infinite then
timer = nil;
else
timer = timer / 60;
end
end
this.update_generic(otomo_move_key, 1, timer);
end
function this.update_generic(otomo_move_key, level, timer, duration)
duration = duration or timer;
local otomo_move = this.list[otomo_move_key];
if otomo_move == nil then
local name = language.current_language.otomo_moves[otomo_move_key];
otomo_move = buffs.new(buffs.types.otomo_move, otomo_move_key, name, level, duration);
this.list[otomo_move_key] = otomo_move;
else
otomo_move.level = level;
if timer ~= nil then
buffs.update_timer(otomo_move, timer);
end
end
buffs.update_generic_buff(this.list, otomo_moves_type_name, "rousing_roar", nil, nil, player_data, beast_roar_otomo_timer_field);
buffs.update_generic_buff(this.list, otomo_moves_type_name, "power_drum", nil, nil, player_data, kijin_otomo_timer_field);
buffs.update_generic_buff(this.list, otomo_moves_type_name, "go_fight_win", nil, nil, player_data, runhigh_otomo_timer_field);
end
function this.init_names()

412
reframework/autorun/MHR_Overlay/Buffs/skills.lua
View File

@@ -29,7 +29,7 @@ local json = json;
local log = log;
local fs = fs;
local next = next;
local type = type;
local skills_type_name = type;
local setmetatable = setmetatable;
local getmetatable = getmetatable;
local assert = assert;
@@ -73,6 +73,8 @@ this.list = {
resentment = nil
};
local skills_type_name = "skills";
local skill_data_list = {
-- 1 Pl_EquipSkill_000 Attack Boost
-- 2 Pl_EquipSkill_001 Agitator
@@ -231,7 +233,7 @@ local skill_data_list = {
-- 147 Pl_EquipSkill_235 Inspiration
}
local burst_breakpoint = 5;
local burst_breakpoints = {5};
local kushara_daora_soul_breakpoint = 5;
local intrepid_heart_minimal_value = 400;
local dereliction_breakpoints = {100, 50};
@@ -336,7 +338,7 @@ local get_hunter_wire_skill_231_num_method = player_quest_base_type_def:get_meth
local qeree = {};
function this.update(player, player_data)
function this.update(player, player_data, weapon_type)
--local item_parameter = get_ref_item_parameter_method:call(singletons.player_manager);
--if item_parameter == nil then
-- error_handler.report("skills.update", "Failed to access Data: item_parameter");
@@ -385,8 +387,7 @@ function this.update(player, player_data)
this.update_equipped_skill_data(player);
this.update_dereliction(player_data);
this.update_wind_mantle(player);
this.update_wind_mantle(player, weapon_type);
this.update_maximum_might(player_data);
this.update_bloodlust();
this.update_frenzied_bloodlust(player, player_data);
@@ -394,30 +395,49 @@ function this.update(player, player_data)
this.update_dragonheart();
this.update_resentment(player_data);
this.update_generic_number_value_field("burst", player_data,
rengeki_power_up_count_field, rengeki_power_up_timer_field, false, nil, burst_breakpoint);
this.update_generic_skill("dereliction", player_data, symbiosis_skill_lost_vital_field,
nil, nil, nil, nil, true, nil, dereliction_breakpoints);
this.update_generic_number_value_field("kushala_daora_soul", player_data,
hyakuryu_dragon_power_up_count_field, hyakuryu_dragon_power_up_timer_field, false, nil, kushara_daora_soul_breakpoint);
this.update_generic_skill("burst", player_data, rengeki_power_up_count_field,
player_data, rengeki_power_up_timer_field, nil, nil, false, nil, burst_breakpoints);
this.update_generic_number_value_field("intrepid_heart", player_data, equip_skill_223_accumulator_field, nil, true, intrepid_heart_minimal_value);
this.update_generic_timer("latent_power", player, power_freedom_timer_field);
this.update_generic_timer("protective_polish", player, sharpness_gauge_boost_timer_field);
this.update_generic_timer("grinder_s", player_data, brand_new_sharpness_adjust_up_timer_field);
this.update_generic_timer("counterstrike", player_data, counterattack_powerup_timer_field);
this.update_generic_timer("affinity_sliding", player_data, sliding_powerup_timer_field);
this.update_generic_timer("coalescence", player_data, disaster_turn_powerup_timer_field);
this.update_generic_timer("adrenaline_rush", player_data, equip_skill_208_atk_up_field);
this.update_generic_timer("wall_runner", player_data, wall_run_powerup_timer_field);
this.update_generic_timer("offensive_guard", player_data, equip_skill_036_timer_field);
this.update_generic_timer("hellfire_cloak", player_data, onibi_powerup_timer_field);
this.update_generic_timer("agitator", player_data, challenge_timer_field, true);
this.update_generic_timer("furious", player_data, furious_skill_stamina_buff_second_timer_field);
this.update_generic_timer("status_trigger", player_data, equip_skill_222_timer_field);
this.update_generic_skill("kushala_daora_soul", player_data, hyakuryu_dragon_power_up_count_field,
player_data, hyakuryu_dragon_power_up_timer_field, nil, nil, false, nil, {kushara_daora_soul_breakpoint});
this.update_generic_boolean_value_method("heaven_sent", player, is_active_equip_skill_230_method);
this.update_generic_boolean_value_method("heroics", player, is_predicament_power_up_method);
this.update_generic_boolean_value_method("resuscitate", player, is_debuff_state_method);
this.update_generic_skill("intrepid_heart", player_data, equip_skill_223_accumulator_field,
nil, nil, nil, nil, true, intrepid_heart_minimal_value);
this.update_generic_skill("latent_power", nil, nil, player, power_freedom_timer_field);
this.update_generic_skill("protective_polish", nil, nil, player, sharpness_gauge_boost_timer_field);
this.update_generic_skill("grinder_s", nil, nil, player_data, brand_new_sharpness_adjust_up_timer_field);
this.update_generic_skill("counterstrike", nil, nil, player_data, counterattack_powerup_timer_field);
this.update_generic_skill("affinity_sliding", nil, nil, player_data, sliding_powerup_timer_field);
this.update_generic_skill("coalescence", nil, nil, player_data, disaster_turn_powerup_timer_field);
this.update_generic_skill("adrenaline_rush", nil, nil, player_data, equip_skill_208_atk_up_field);
this.update_generic_skill("wall_runner", nil, nil, player_data, wall_run_powerup_timer_field);
this.update_generic_skill("offensive_guard", nil, nil, player_data, equip_skill_036_timer_field);
this.update_generic_skill("hellfire_cloak", nil, nil, player_data, onibi_powerup_timer_field);
this.update_generic_skill("agitator", nil, nil, player_data, challenge_timer_field, true);
this.update_generic_skill("furious", nil, nil, player_data, furious_skill_stamina_buff_second_timer_field);
this.update_generic_skill("status_trigger", nil, nil, player_data, equip_skill_222_timer_field);
this.update_generic_skill("heaven_sent", player, is_active_equip_skill_230_method);
this.update_generic_skill("heroics", player, is_predicament_power_up_method);
this.update_generic_skill("resuscitate", player, is_debuff_state_method);
end
function this.update_generic_skill(skill_key, value_owner, value_holder, timer_owner, timer_holder, duration_owner, duration_holder,
is_infinite, minimal_value, level_breakpoints)
local skill_data = skill_data_list[skill_key];
if skill_data ~= nil and not skill_data.is_equipped then
this.list[skill_key] = nil;
return;
end
buffs.update_generic_buff(this.list, skills_type_name, skill_key,
value_owner, value_holder, timer_owner, timer_holder, duration_owner, duration_holder,
is_infinite, minimal_value, level_breakpoints);
end
function this.update_equipped_skill_data(player)
@@ -461,295 +481,7 @@ function this.update_equipped_skill_data(player)
end
end
function this.update_generic_timer(skill_key, timer_owner, timer_field, is_infinite)
if is_infinite == nil then is_infinite = false; end
local skill_data = skill_data_list[skill_key];
if skill_data ~= nil and not skill_data.is_equipped then
this.list[skill_key] = nil;
return;
end
local timer = nil;
if timer_field ~= nil then
timer = timer_field:get_data(timer_owner);
if timer == nil then
error_handler.report("skills.update_generic_timer", string.format("Failed to access Data: %s_timer", skill_key));
return;
end
if utils.number.is_equal(timer, 0) then
this.list[skill_key] = nil;
return;
end
if is_infinite then
timer = nil;
else
timer = timer / 60;
end
end
this.update_generic(skill_key, 1, timer);
end
function this.update_generic_number_value_field(skill_key, timer_owner, value_field, timer_field, is_infinite, minimal_value, level_breakpoint)
if minimal_value == nil then minimal_value = 1; end
level_breakpoint = level_breakpoint or 1000000;
if is_infinite == nil then is_infinite = false; end
local skill_data = skill_data_list[skill_key];
if skill_data ~= nil and not skill_data.is_equipped then
this.list[skill_key] = nil;
return;
end
local level = 1;
if value_field ~= nil then
local value = value_field:get_data(timer_owner);
if value == nil then
error_handler.report("skills.update_generic_number_value_field", string.format("Failed to access Data: %s_value", skill_key));
return;
end
if value < minimal_value then
this.list[skill_key] = nil;
return;
end
if value >= level_breakpoint then
level = 2;
end
end
local timer = nil;
if timer_field ~= nil then
timer = timer_field:get_data(timer_owner);
if timer == nil then
error_handler.report("skills.update_generic_number_value_field", string.format("Failed to access Data: %s_timer", skill_key));
return;
end
if value_field == nil and utils.number.is_equal(timer, 0) then
this.list[skill_key] = nil;
return;
end
if is_infinite then
timer = nil;
else
timer = timer / 60;
end
end
this.update_generic(skill_key, level, timer);
end
function this.update_generic_boolean_value_field(skill_key, timer_owner, value_field, timer_field, is_infinite, minimal_value)
if minimal_value == nil then minimal_value = true; end
if is_infinite == nil then is_infinite = false; end
local skill_data = skill_data_list[skill_key];
if skill_data ~= nil and not skill_data.is_equipped then
this.list[skill_key] = nil;
return;
end
if value_field ~= nil then
local value = value_field:get_data(timer_owner);
if value == nil then
error_handler.report("skills.update_generic_boolean_value_field", string.format("Failed to access Data: %s_value", skill_key));
return;
end
if value < minimal_value then
this.list[skill_key] = nil;
return;
end
end
local timer = nil;
if timer_field ~= nil then
timer = timer_field:get_data(timer_owner);
if timer == nil then
error_handler.report("skills.update_generic_boolean_value_field", string.format("Failed to access Data: %s_timer", skill_key));
return;
end
if value_field == nil and utils.number.is_equal(timer, 0) then
this.list[skill_key] = nil;
return;
end
if is_infinite then
timer = nil;
else
timer = timer / 60;
end
end
this.update_generic(skill_key, 1, timer);
end
function this.update_generic_number_value_method(skill_key, timer_owner, value_method, timer_field, is_infinite, minimal_value, level_breakpoint)
if minimal_value == nil then minimal_value = 1; end
level_breakpoint = level_breakpoint or 1000000;
if is_infinite == nil then is_infinite = false; end
local skill_data = skill_data_list[skill_key];
if skill_data ~= nil and not skill_data.is_equipped then
this.list[skill_key] = nil;
return;
end
local level = 1;
if value_method ~= nil then
local value = value_method:call(timer_owner);
if value == nil then
error_handler.report("skills.update_generic_number_value_method", string.format("Failed to access Data: %s_value", skill_key));
return;
end
if value < minimal_value then
this.list[skill_key] = nil;
return;
end
if value >= level_breakpoint then
level = 2;
end
end
local timer = nil;
if timer_field ~= nil then
timer = timer_field:get_data(timer_owner);
if timer == nil then
error_handler.report("skills.update_generic_number_value_method", string.format("Failed to access Data: %s_timer", skill_key));
return;
end
if value_method == nil and utils.number.is_equal(timer, 0) then
this.list[skill_key] = nil;
return;
end
if is_infinite then
timer = nil;
else
timer = timer / 60;
end
end
this.update_generic(skill_key, level, timer);
end
function this.update_generic_boolean_value_method(skill_key, timer_owner, value_method, timer_field, is_infinite, minimal_value)
if minimal_value == nil then minimal_value = true; end
if is_infinite == nil then is_infinite = false; end
local skill_data = skill_data_list[skill_key];
if skill_data ~= nil and not skill_data.is_equipped then
this.list[skill_key] = nil;
return;
end
if value_method ~= nil then
local value = value_method:call(timer_owner);
if value == nil then
error_handler.report("skills.update_generic_boolean_value_method", string.format("Failed to access Data: %s_value", skill_key));
return;
end
if value ~= minimal_value then
this.list[skill_key] = nil;
return;
end
end
local timer = nil;
if timer_field ~= nil then
timer = timer_field:get_data(timer_owner);
if timer == nil then
error_handler.report("skills.update_generic_boolean_value_method", string.format("Failed to access Data: %s_timer", skill_key));
return;
end
if value_method == nil and utils.number.is_equal(timer, 0) then
this.list[skill_key] = nil;
return;
end
if is_infinite then
timer = nil;
else
timer = timer / 60;
end
end
this.update_generic(skill_key, 1, timer);
end
function this.update_generic(skill_key, level, timer, duration)
duration = duration or timer;
local skill = this.list[skill_key];
if skill == nil then
local name = language.current_language.skills[skill_key];
skill = buffs.new(buffs.types.skill, skill_key, name, level, duration);
this.list[skill_key] = skill;
else
skill.level = level;
if timer ~= nil then
buffs.update_timer(skill, timer);
end
end
end
function this.update_dereliction(player_data)
if not skill_data_list.dereliction.is_equipped then
this.list.dereliction = nil;
return;
end
local dereliction_value = symbiosis_skill_lost_vital_field:get_data(player_data);
if dereliction_value == nil then
error_handler.report("skills.update_derelection", "Failed to access Data: dereliction_value");
return;
end
if dereliction_value == 0 then
this.list.dereliction = nil;
return;
end
local level = 1;
for index, breakpoint in ipairs(dereliction_breakpoints) do
if dereliction_value >= breakpoint then
level = 4 - index;
break;
end
end
local skill = this.list.dereliction;
if skill == nil then
local name = language.current_language.skills.dereliction;
skill = buffs.new(buffs.types.skill, "dereliction", name, level);
this.list.dereliction = skill;
else
skill.level = level;
end
end
function this.update_wind_mantle(player)
function this.update_wind_mantle(player, weapon_type)
local wind_mantle_timer = equip_skill_226_attack_off_timer_field:get_data(player);
if wind_mantle_timer == nil then
error_handler.report("skills.update_wind_mantle", "Failed to access Data: wind_mantle_timer");
@@ -767,38 +499,19 @@ function this.update_wind_mantle(player)
return;
end
local weapon_type = player_weapon_type_field:get_data(player);
if player == nil then
error_handler.report("skills.update_wind_mantle", "Failed to access Data: weapon_type");
return;
end
local breakpoints = wind_mantle_breakpoints;
for weapon_type_index, special_breakpoints in pairs(wind_mantle_special_breakpoints) do
if weapon_type == weapon_type_index then
breakpoints = special_breakpoints;
break;
end
end
local level = 1;
local breakpoints = wind_mantle_special_breakpoints[weapon_type] or wind_mantle_breakpoints;
local breakpoint_count = #breakpoints;
for index, breakpoint in ipairs(breakpoints) do
if wind_mantle_value >= breakpoint then
level = 4 - index;
level = 2 + breakpoint_count - index;
break;
end
end
local skill = this.list.wind_mantle;
if skill == nil then
local name = language.current_language.skills.wind_mantle;
skill = buffs.new(buffs.types.skill, "wind_mantle", name, level, wind_mantle_duration);
this.list.wind_mantle = skill;
else
skill.level = level;
buffs.update_timer(skill, wind_mantle_duration - (wind_mantle_timer / 60));
end
buffs.update_generic(this.list, skills_type_name, "wind_mantle", level, wind_mantle_duration - (wind_mantle_timer / 60), wind_mantle_duration);
end
function this.update_maximum_might(player_data)
@@ -829,16 +542,14 @@ function this.update_maximum_might(player_data)
local name = language.current_language.skills.maximum_might;
if whole_body_timer < maximum_might_previous_timer_value then
skill = buffs.new(type, "maximum_might", name, 1);
this.list.maximum_might = skill;
this.list.maximum_might = buffs.new(skills_type_name, "maximum_might", name, 1);
elseif is_timer_zero then
if maximum_might_delay_timer == nil then
maximum_might_delay_timer = time.new_delay_timer(function()
maximum_might_delay_timer = nil;
skill = buffs.new(type, "maximum_might", name, 1);
this.list.maximum_might = skill;
this.list.maximum_might = buffs.new(skills_type_name, "maximum_might", name, 1);
end, 3.5);
end
@@ -864,7 +575,7 @@ function this.update_bloodlust()
if this.list.bloodlust == nil then
local name = language.current_language.skills.bloodlust;
this.list.bloodlust = buffs.new(buffs.types.skill, "bloodlust", name, 0);
this.list.bloodlust = buffs.new(skills_type_name, "bloodlust", name);
end
end
@@ -915,9 +626,8 @@ function this.update_frenzied_bloodlust(player, player_data)
timer = equip_skill_231_wp_off_timer;
end
this.update_generic("frenzied_bloodlust", 1, timer / 60);
local skill = this.list.frenzied_bloodlust;
local skill = buffs.update_generic(this.list, skills_type_name, "frenzied_bloodlust", 1, timer / 60);
if is_wp_off_timer_max then
skill.duration = frenzied_bloodlust_duration / 60;
else
@@ -936,7 +646,7 @@ function this.update_peak_performance()
return;
end
this.update_generic("peak_performance", 1);
buffs.update_generic(this.list, skills_type_name, "peak_performance");
end
function this.update_dragonheart()
@@ -959,7 +669,7 @@ function this.update_dragonheart()
return;
end
this.update_generic("dragonheart", 1);
buffs.update_generic(this.list, skills_type_name, "dragonheart");
end
function this.update_resentment(player_data)
@@ -979,7 +689,7 @@ function this.update_resentment(player_data)
return;
end
this.update_generic("resentment", 1);
buffs.update_generic(this.list, skills_type_name, "resentment");
end
function this.init_names()