1323 lines
41 KiB
TOML
1323 lines
41 KiB
TOML
[manifest]
|
|
version = "1.0.0"
|
|
dump_lua = true
|
|
priority = -10
|
|
# temp solution, nothing matches if -10
|
|
|
|
## G.FUNCS.evaluate_play()
|
|
# evaluate main scoring
|
|
|
|
[[patches]]
|
|
[patches.regex]
|
|
target = 'functions/state_events.lua'
|
|
pattern = '''(?<indent>[\t ]*)(?<handtext>if modded then update_hand_text\(\{sound = 'chips2', modded = modded\}, \{chips = hand_chips, mult = mult\}\) end)(.*\n)*?\s+(?<delimiter>--\++--)'''
|
|
position = 'at'
|
|
line_prepend = '$indent'
|
|
payload = '''$handtext
|
|
delay(0.3)
|
|
for _, v in ipairs(SMODS.get_card_areas('playing_cards')) do
|
|
SMODS.calculate_main_scoring({cardarea = v, full_hand = G.play.cards, scoring_hand = scoring_hand, scoring_name = text, poker_hands = poker_hands}, v == G.play and scoring_hand or nil)
|
|
delay(0.3)
|
|
end
|
|
$delimiter'''
|
|
## eval_card()
|
|
# handle debuffed playing cards
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = "functions/common_events.lua"
|
|
pattern = '''
|
|
function eval_card(card, context)
|
|
context = context or {}
|
|
local ret = {}
|
|
'''
|
|
position = 'at'
|
|
match_indent = true
|
|
payload = '''
|
|
function eval_card(card, context)
|
|
if card.ability.set ~= 'Joker' and card.debuff then return {}, {} end
|
|
context = context or {}
|
|
local ret = {}
|
|
'''
|
|
|
|
# built in config values
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = "functions/common_events.lua"
|
|
pattern = '''
|
|
if context.cardarea == G.play then
|
|
local chips = card:get_chip_bonus()
|
|
if chips > 0 then
|
|
ret.chips = chips
|
|
end
|
|
|
|
local mult = card:get_chip_mult()
|
|
if mult > 0 then
|
|
ret.mult = mult
|
|
end
|
|
|
|
local x_mult = card:get_chip_x_mult(context)
|
|
if x_mult > 0 then
|
|
ret.x_mult = x_mult
|
|
end
|
|
|
|
local p_dollars = card:get_p_dollars()
|
|
if p_dollars > 0 then
|
|
ret.p_dollars = p_dollars
|
|
end
|
|
|
|
local jokers = card:calculate_joker(context)
|
|
if jokers then
|
|
ret.jokers = jokers
|
|
end
|
|
|
|
local edition = card:get_edition(context)
|
|
if edition then
|
|
ret.edition = edition
|
|
end
|
|
end
|
|
'''
|
|
match_indent = true
|
|
position = "at"
|
|
payload = """
|
|
if context.cardarea == G.play and context.main_scoring then
|
|
ret.playing_card = {}
|
|
local chips = card:get_chip_bonus()
|
|
if chips ~= 0 then
|
|
ret.playing_card.chips = chips
|
|
end
|
|
|
|
local mult = card:get_chip_mult()
|
|
if mult ~= 0 then
|
|
ret.playing_card.mult = mult
|
|
end
|
|
|
|
local x_mult = card:get_chip_x_mult(context)
|
|
if x_mult > 0 then
|
|
ret.playing_card.x_mult = x_mult
|
|
end
|
|
|
|
local p_dollars = card:get_p_dollars()
|
|
if p_dollars > 0 then
|
|
ret.playing_card.p_dollars = p_dollars
|
|
end
|
|
|
|
-- TARGET: main scoring on played cards
|
|
|
|
local jokers = card:calculate_joker(context)
|
|
if jokers then
|
|
ret.jokers = jokers
|
|
end
|
|
|
|
local edition = card:calculate_edition(context)
|
|
if edition then
|
|
ret.edition = edition
|
|
end
|
|
end
|
|
if context.end_of_round and context.cardarea == G.hand and context.playing_card_end_of_round then
|
|
local end_of_round = card:get_end_of_round_effect(context)
|
|
if end_of_round then
|
|
ret.end_of_round = end_of_round
|
|
end
|
|
end
|
|
"""
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = "functions/common_events.lua"
|
|
pattern = '''
|
|
if context.cardarea == G.hand then
|
|
local h_mult = card:get_chip_h_mult()
|
|
if h_mult > 0 then
|
|
ret.h_mult = h_mult
|
|
end
|
|
|
|
local h_x_mult = card:get_chip_h_x_mult()
|
|
if h_x_mult > 0 then
|
|
ret.x_mult = h_x_mult
|
|
end
|
|
'''
|
|
match_indent = true
|
|
position = "at"
|
|
payload = """
|
|
if context.cardarea == G.hand and context.main_scoring then
|
|
ret.playing_card = {}
|
|
local h_mult = card:get_chip_h_mult()
|
|
if h_mult ~= 0 then
|
|
ret.playing_card.h_mult = h_mult
|
|
end
|
|
|
|
local h_x_mult = card:get_chip_h_x_mult()
|
|
if h_x_mult > 0 then
|
|
ret.playing_card.x_mult = h_x_mult
|
|
end
|
|
|
|
-- TARGET: main scoring on held cards
|
|
"""
|
|
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = "functions/common_events.lua"
|
|
pattern = '''
|
|
local seals = card:calculate_seal(context)
|
|
if seals then
|
|
ret.seals = seals
|
|
end
|
|
'''
|
|
match_indent = true
|
|
position = "at"
|
|
payload = """
|
|
if card.ability.set == 'Enhanced' then
|
|
local enhancement = card:calculate_enhancement(context)
|
|
if enhancement then
|
|
ret.enhancement = enhancement
|
|
end
|
|
end
|
|
if card.edition then
|
|
local edition = card:calculate_edition(context)
|
|
if edition then
|
|
ret.edition = edition
|
|
end
|
|
end
|
|
if card.seal then
|
|
local seals = card:calculate_seal(context)
|
|
if seals then
|
|
ret.seals = seals
|
|
end
|
|
end
|
|
for k,v in pairs(SMODS.Stickers) do
|
|
local sticker = card:calculate_sticker(context, k)
|
|
if sticker then
|
|
ret[v] = sticker
|
|
end
|
|
end
|
|
|
|
-- TARGET: evaluate your own repetition effects
|
|
"""
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = "functions/common_events.lua"
|
|
pattern = "if context.cardarea == G.jokers or context.card == G.consumeables then"
|
|
match_indent = true
|
|
position = "before"
|
|
payload = """
|
|
if card.ability.set == 'Enhanced' then
|
|
local enhancement = card:calculate_enhancement(context)
|
|
if enhancement then
|
|
ret.enhancement = enhancement
|
|
end
|
|
end
|
|
if card.edition then
|
|
local edition = card:calculate_edition(context)
|
|
if edition then
|
|
ret.edition = edition
|
|
end
|
|
end
|
|
if card.seal and not card.ability.extra_enhancement then
|
|
local seals = card:calculate_seal(context)
|
|
if seals then
|
|
ret.seals = seals
|
|
end
|
|
end
|
|
for k,v in pairs(SMODS.Stickers) do
|
|
local sticker = card:calculate_sticker(context, k)
|
|
if sticker then
|
|
ret[v] = sticker
|
|
end
|
|
end
|
|
|
|
-- TARGET: evaluate your own general effects
|
|
"""
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = "functions/common_events.lua"
|
|
pattern = '''
|
|
if context.cardarea == G.jokers or context.card == G.consumeables then
|
|
local jokers = nil
|
|
if context.edition then
|
|
jokers = card:get_edition(context)
|
|
elseif context.other_joker then
|
|
jokers = context.other_joker:calculate_joker(context)
|
|
else
|
|
jokers = card:calculate_joker(context)
|
|
end
|
|
if jokers then
|
|
ret.jokers = jokers
|
|
end
|
|
end
|
|
|
|
return ret'''
|
|
match_indent = true
|
|
position = "at"
|
|
payload = """
|
|
local post_trig = {}
|
|
local areas = SMODS.get_card_areas('jokers')
|
|
local area_set = {}
|
|
for _,v in ipairs(areas) do area_set[v] = true end
|
|
if card.area and area_set[card.area] then
|
|
local jokers, triggered = card:calculate_joker(context)
|
|
if jokers or triggered then
|
|
ret.jokers = jokers
|
|
if not (context.retrigger_joker_check or context.retrigger_joker) then
|
|
local retriggers = SMODS.calculate_retriggers(card, context, ret)
|
|
if next(retriggers) then
|
|
ret.retriggers = retriggers
|
|
end
|
|
end
|
|
if not context.post_trigger and not context.retrigger_joker_check and SMODS.optional_features.post_trigger then
|
|
SMODS.calculate_context({blueprint_card = context.blueprint_card, post_trigger = true, other_card = card, other_context = context, other_ret = ret}, post_trig)
|
|
end
|
|
end
|
|
end
|
|
|
|
return ret, post_trig
|
|
"""
|
|
# patch card_eval_status_text to allow G.deck usage
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = "functions/common_events.lua"
|
|
pattern = '''
|
|
elseif card.area == G.hand then'''
|
|
match_indent = true
|
|
position = "at"
|
|
payload = """
|
|
elseif card.area == G.hand or card.area == G.deck then
|
|
"""
|
|
|
|
# card_eval_status_text alignment patches
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'functions/common_events.lua'
|
|
match_indent = true
|
|
position = 'before'
|
|
pattern = '''elseif card.area == G.hand or card.area == G.deck then'''
|
|
payload = '''elseif card == G.deck then
|
|
y_off = -0.05*G.CARD_H
|
|
card_aligned = 'tm'
|
|
elseif card.area == G.discard or card.area == G.vouchers then
|
|
y_off = card.area == G.discard and -0.35*G.CARD_H or -0.65*G.CARD_H
|
|
card = G.deck.cards[1] or G.deck
|
|
card_aligned = 'tm'
|
|
'''
|
|
|
|
# G.FUNCS.evaluate_play()
|
|
|
|
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = "functions/state_events.lua"
|
|
pattern = '''
|
|
--calculate the card edition effects
|
|
if effects[ii].edition then
|
|
hand_chips = mod_chips(hand_chips + (effects[ii].edition.chip_mod or 0))
|
|
mult = mult + (effects[ii].edition.mult_mod or 0)
|
|
mult = mod_mult(mult*(effects[ii].edition.x_mult_mod or 1))
|
|
update_hand_text({delay = 0}, {
|
|
chips = effects[ii].edition.chip_mod and hand_chips or nil,
|
|
mult = (effects[ii].edition.mult_mod or effects[ii].edition.x_mult_mod) and mult or nil,
|
|
})
|
|
card_eval_status_text(scoring_hand[i], 'extra', nil, percent, nil, {
|
|
message = (effects[ii].edition.chip_mod and localize{type='variable',key='a_chips',vars={effects[ii].edition.chip_mod}}) or
|
|
(effects[ii].edition.mult_mod and localize{type='variable',key='a_mult',vars={effects[ii].edition.mult_mod}}) or
|
|
(effects[ii].edition.x_mult_mod and localize{type='variable',key='a_xmult',vars={effects[ii].edition.x_mult_mod}}),
|
|
chip_mod = effects[ii].edition.chip_mod,
|
|
mult_mod = effects[ii].edition.mult_mod,
|
|
x_mult_mod = effects[ii].edition.x_mult_mod,
|
|
colour = G.C.DARK_EDITION,
|
|
edition = true})
|
|
end
|
|
'''
|
|
match_indent = true
|
|
position = "at"
|
|
payload = ''
|
|
|
|
## Remove base game calculations
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = "functions/state_events.lua"
|
|
pattern = '''
|
|
scoring_hand[i].lucky_trigger = nil
|
|
|
|
for ii = 1, #effects do
|
|
--If chips added, do chip add event and add the chips to the total
|
|
if effects[ii].chips then
|
|
if effects[ii].card then juice_card(effects[ii].card) end
|
|
hand_chips = mod_chips(hand_chips + effects[ii].chips)
|
|
update_hand_text({delay = 0}, {chips = hand_chips})
|
|
card_eval_status_text(scoring_hand[i], 'chips', effects[ii].chips, percent)
|
|
end
|
|
|
|
--If mult added, do mult add event and add the mult to the total
|
|
if effects[ii].mult then
|
|
if effects[ii].card then juice_card(effects[ii].card) end
|
|
mult = mod_mult(mult + effects[ii].mult)
|
|
update_hand_text({delay = 0}, {mult = mult})
|
|
card_eval_status_text(scoring_hand[i], 'mult', effects[ii].mult, percent)
|
|
end
|
|
|
|
--If play dollars added, add dollars to total
|
|
if effects[ii].p_dollars then
|
|
if effects[ii].card then juice_card(effects[ii].card) end
|
|
ease_dollars(effects[ii].p_dollars)
|
|
card_eval_status_text(scoring_hand[i], 'dollars', effects[ii].p_dollars, percent)
|
|
end
|
|
|
|
--If dollars added, add dollars to total
|
|
if effects[ii].dollars then
|
|
if effects[ii].card then juice_card(effects[ii].card) end
|
|
ease_dollars(effects[ii].dollars)
|
|
card_eval_status_text(scoring_hand[i], 'dollars', effects[ii].dollars, percent)
|
|
end
|
|
|
|
--Any extra effects
|
|
if effects[ii].extra then
|
|
if effects[ii].card then juice_card(effects[ii].card) end
|
|
local extras = {mult = false, hand_chips = false}
|
|
if effects[ii].extra.mult_mod then mult =mod_mult( mult + effects[ii].extra.mult_mod);extras.mult = true end
|
|
if effects[ii].extra.chip_mod then hand_chips = mod_chips(hand_chips + effects[ii].extra.chip_mod);extras.hand_chips = true end
|
|
if effects[ii].extra.swap then
|
|
local old_mult = mult
|
|
mult = mod_mult(hand_chips)
|
|
hand_chips = mod_chips(old_mult)
|
|
extras.hand_chips = true; extras.mult = true
|
|
end
|
|
if effects[ii].extra.func then effects[ii].extra.func() end
|
|
update_hand_text({delay = 0}, {chips = extras.hand_chips and hand_chips, mult = extras.mult and mult})
|
|
card_eval_status_text(scoring_hand[i], 'extra', nil, percent, nil, effects[ii].extra)
|
|
end
|
|
|
|
--If x_mult added, do mult add event and mult the mult to the total
|
|
if effects[ii].x_mult then
|
|
if effects[ii].card then juice_card(effects[ii].card) end
|
|
mult = mod_mult(mult*effects[ii].x_mult)
|
|
update_hand_text({delay = 0}, {mult = mult})
|
|
card_eval_status_text(scoring_hand[i], 'x_mult', effects[ii].x_mult, percent)
|
|
end
|
|
|
|
|
|
end
|
|
end
|
|
end
|
|
'''
|
|
match_indent = true
|
|
position = "at"
|
|
payload = '''
|
|
-- Base game calculation removed
|
|
SMODS.trigger_effects(effects, scoring_hand[i])
|
|
local deck_effect = G.GAME.selected_back:trigger_effect({cardarea = G.play, full_hand = G.play.cards, scoring_hand = scoring_hand, scoring_name = text, poker_hands = poker_hands, other_card = scoring_hand[i], individual = true})
|
|
if deck_effect then SMODS.calculate_effect(deck_effect, G.deck.cards[1] or G.deck) end
|
|
scoring_hand[i].lucky_trigger = nil
|
|
end
|
|
scoring_hand[i].extra_enhancements = nil
|
|
end
|
|
'''
|
|
|
|
# Add deck/discard individual contexts
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'functions/state_events.lua'
|
|
position = 'before'
|
|
match_indent = true
|
|
pattern = '''
|
|
--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
|
|
--Joker Effects
|
|
--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++--'''
|
|
payload = '''
|
|
|
|
'''
|
|
|
|
# Joker Effects
|
|
# Edition effects
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = "functions/state_events.lua"
|
|
pattern = '''
|
|
--calculate the joker edition effects
|
|
local edition_effects = eval_card(_card, {cardarea = G.jokers, full_hand = G.play.cards, scoring_hand = scoring_hand, scoring_name = text, poker_hands = poker_hands, edition = true})
|
|
if edition_effects.jokers then
|
|
edition_effects.jokers.edition = true
|
|
if edition_effects.jokers.chip_mod then
|
|
hand_chips = mod_chips(hand_chips + edition_effects.jokers.chip_mod)
|
|
update_hand_text({delay = 0}, {chips = hand_chips})
|
|
card_eval_status_text(_card, 'jokers', nil, percent, nil, {
|
|
message = localize{type='variable',key='a_chips',vars={edition_effects.jokers.chip_mod}},
|
|
chip_mod = edition_effects.jokers.chip_mod,
|
|
colour = G.C.EDITION,
|
|
edition = true})
|
|
end
|
|
if edition_effects.jokers.mult_mod then
|
|
mult = mod_mult(mult + edition_effects.jokers.mult_mod)
|
|
update_hand_text({delay = 0}, {mult = mult})
|
|
card_eval_status_text(_card, 'jokers', nil, percent, nil, {
|
|
message = localize{type='variable',key='a_mult',vars={edition_effects.jokers.mult_mod}},
|
|
mult_mod = edition_effects.jokers.mult_mod,
|
|
colour = G.C.DARK_EDITION,
|
|
edition = true})
|
|
end
|
|
percent = percent+percent_delta
|
|
end'''
|
|
match_indent = true
|
|
position = "at"
|
|
payload = '''
|
|
local effects = {}
|
|
-- remove base game joker edition calc
|
|
local eval = eval_card(_card, {cardarea = G.jokers, full_hand = G.play.cards, scoring_hand = scoring_hand, scoring_name = text, poker_hands = poker_hands, edition = true, pre_joker = true})
|
|
if eval.edition then effects[#effects+1] = eval end
|
|
|
|
'''
|
|
# Edition mult effects
|
|
## extra end to fix syntax from adding joker-like areas
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = "functions/state_events.lua"
|
|
pattern = '''
|
|
if edition_effects.jokers then
|
|
if edition_effects.jokers.x_mult_mod then
|
|
mult = mod_mult(mult*edition_effects.jokers.x_mult_mod)
|
|
update_hand_text({delay = 0}, {mult = mult})
|
|
card_eval_status_text(_card, 'jokers', nil, percent, nil, {
|
|
message = localize{type='variable',key='a_xmult',vars={edition_effects.jokers.x_mult_mod}},
|
|
x_mult_mod = edition_effects.jokers.x_mult_mod,
|
|
colour = G.C.EDITION,
|
|
edition = true})
|
|
end
|
|
percent = percent+percent_delta
|
|
end
|
|
end'''
|
|
match_indent = false
|
|
position = "at"
|
|
payload = '''
|
|
-- calculate edition multipliers
|
|
local eval = eval_card(_card, {cardarea = G.jokers, full_hand = G.play.cards, scoring_hand = scoring_hand, scoring_name = text, poker_hands = poker_hands, edition = true, post_joker = true})
|
|
if eval.edition then effects[#effects+1] = eval end
|
|
|
|
SMODS.trigger_effects(effects, _card)
|
|
local deck_effect = G.GAME.selected_back:trigger_effect({full_hand = G.play.cards, scoring_hand = scoring_hand, scoring_name = text, poker_hands = poker_hands, other_joker = _card.ability.set == 'Joker' and _card or false, other_consumeable = _card.ability.set ~= 'Joker' and _card or false})
|
|
if deck_effect then SMODS.calculate_effect(deck_effect, G.deck.cards[1] or G.deck) end
|
|
end end
|
|
'''
|
|
# Joker effects
|
|
|
|
# allows adding other areas (syntax is fixed further down)
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'functions/state_events.lua'
|
|
match_indent = true
|
|
position = 'at'
|
|
pattern = '''for i=1, #G.jokers.cards + #G.consumeables.cards do
|
|
local _card = G.jokers.cards[i] or G.consumeables.cards[i - #G.jokers.cards]'''
|
|
payload = '''for _, area in ipairs(SMODS.get_card_areas('jokers')) do for _, _card in ipairs(area.cards) do'''
|
|
|
|
## I am NOT converting this to regex (yet)
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = "functions/state_events.lua"
|
|
pattern = '''
|
|
--calculate the joker effects
|
|
local effects = eval_card(_card, {cardarea = G.jokers, full_hand = G.play.cards, scoring_hand = scoring_hand, scoring_name = text, poker_hands = poker_hands, joker_main = true})
|
|
|
|
--Any Joker effects
|
|
if effects.jokers then
|
|
local extras = {mult = false, hand_chips = false}
|
|
if effects.jokers.mult_mod then mult = mod_mult(mult + effects.jokers.mult_mod);extras.mult = true end
|
|
if effects.jokers.chip_mod then hand_chips = mod_chips(hand_chips + effects.jokers.chip_mod);extras.hand_chips = true end
|
|
if effects.jokers.Xmult_mod then mult = mod_mult(mult*effects.jokers.Xmult_mod);extras.mult = true end
|
|
update_hand_text({delay = 0}, {chips = extras.hand_chips and hand_chips, mult = extras.mult and mult})
|
|
card_eval_status_text(_card, 'jokers', nil, percent, nil, effects.jokers)
|
|
percent = percent+percent_delta
|
|
end'''
|
|
match_indent = true
|
|
position = "at"
|
|
payload = '''
|
|
-- Calculate context.joker_main
|
|
local joker_eval, post = eval_card(_card, {cardarea = G.jokers, full_hand = G.play.cards, scoring_hand = scoring_hand, scoring_name = text, poker_hands = poker_hands, joker_main = true})
|
|
if next(joker_eval) then
|
|
if joker_eval.edition then joker_eval.edition = {} end
|
|
table.insert(effects, joker_eval)
|
|
for _, v in ipairs(post) do effects[#effects+1] = v end
|
|
if joker_eval.retriggers then
|
|
for rt = 1, #joker_eval.retriggers do
|
|
local rt_eval, rt_post = eval_card(_card, {cardarea = G.jokers, full_hand = G.play.cards, scoring_hand = scoring_hand, scoring_name = text, poker_hands = poker_hands, joker_main = true, retrigger_joker = true})
|
|
table.insert(effects, {joker_eval.retriggers[rt]})
|
|
table.insert(effects, rt_eval)
|
|
for _, v in ipairs(rt_post) do effects[#effects+1] = v end
|
|
end
|
|
end
|
|
end'''
|
|
# Joker on Joker effects
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = "functions/state_events.lua"
|
|
pattern = '''
|
|
--Joker on Joker effects
|
|
for _, v in ipairs(G.jokers.cards) do
|
|
local effect = v:calculate_joker{full_hand = G.play.cards, scoring_hand = scoring_hand, scoring_name = text, poker_hands = poker_hands, other_joker = _card}
|
|
if effect then
|
|
local extras = {mult = false, hand_chips = false}
|
|
if effect.mult_mod then mult = mod_mult(mult + effect.mult_mod);extras.mult = true end
|
|
if effect.chip_mod then hand_chips = mod_chips(hand_chips + effect.chip_mod);extras.hand_chips = true end
|
|
if effect.Xmult_mod then mult = mod_mult(mult*effect.Xmult_mod);extras.mult = true end
|
|
if extras.mult or extras.hand_chips then update_hand_text({delay = 0}, {chips = extras.hand_chips and hand_chips, mult = extras.mult and mult}) end
|
|
if extras.mult or extras.hand_chips then card_eval_status_text(v, 'jokers', nil, percent, nil, effect) end
|
|
percent = percent+percent_delta
|
|
end
|
|
end'''
|
|
match_indent = true
|
|
position = "at"
|
|
payload = '''
|
|
-- Calculate context.other_joker effects
|
|
for _, _area in ipairs(SMODS.get_card_areas('jokers')) do
|
|
for _, _joker in ipairs(_area.cards) do
|
|
local other_key = 'other_unknown'
|
|
if _card.ability.set == 'Joker' then other_key = 'other_joker' end
|
|
if _card.ability.consumeable then other_key = 'other_consumeable' end
|
|
if _card.ability.set == 'Voucher' then other_key = 'other_voucher' end
|
|
-- TARGET: add context.other_something identifier to your cards
|
|
local joker_eval,post = eval_card(_joker, {full_hand = G.play.cards, scoring_hand = scoring_hand, scoring_name = text, poker_hands = poker_hands, [other_key] = _card, other_main = _card })
|
|
if next(joker_eval) then
|
|
if joker_eval.edition then joker_eval.edition = {} end
|
|
joker_eval.jokers.juice_card = _joker
|
|
table.insert(effects, joker_eval)
|
|
for _, v in ipairs(post) do effects[#effects+1] = v end
|
|
if joker_eval.retriggers then
|
|
for rt = 1, #joker_eval.retriggers do
|
|
local rt_eval, rt_post = eval_card(_card, {full_hand = G.play.cards, scoring_hand = scoring_hand, scoring_name = text, poker_hands = poker_hands, [other_key] = _card, retrigger_joker = true})
|
|
table.insert(effects, {joker_eval.retriggers[rt]})
|
|
table.insert(effects, rt_eval)
|
|
for _, v in ipairs(rt_post) do effects[#effects+1] = v end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
'''
|
|
|
|
## Fix other evaluations
|
|
# Discarding cards
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = "functions/state_events.lua"
|
|
pattern = '''
|
|
for j = 1, #G.jokers.cards do
|
|
local eval = nil
|
|
eval = G.jokers.cards[j]:calculate_joker({discard = true, other_card = G.hand.highlighted[i], full_hand = G.hand.highlighted})
|
|
if eval then
|
|
if eval.remove then removed = true end
|
|
card_eval_status_text(G.jokers.cards[j], 'jokers', nil, 1, nil, eval)
|
|
end
|
|
end'''
|
|
match_indent = true
|
|
position = "at"
|
|
payload = '''
|
|
local effects = {}
|
|
SMODS.calculate_context({discard = true, other_card = G.hand.highlighted[i], full_hand = G.hand.highlighted}, effects)
|
|
SMODS.trigger_effects(effects)
|
|
for _, eval in pairs(effects) do
|
|
if type(eval) == 'table' then
|
|
for key, eval2 in pairs(eval) do
|
|
if key == 'remove' or (type(eval2) == 'table' and eval2.remove) then removed = true end
|
|
end
|
|
end
|
|
end'''
|
|
|
|
# context.before
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = "functions/state_events.lua"
|
|
pattern = '''
|
|
for i=1, #G.jokers.cards do
|
|
--calculate the joker effects
|
|
local effects = eval_card(G.jokers.cards[i], {cardarea = G.jokers, full_hand = G.play.cards, scoring_hand = scoring_hand, scoring_name = text, poker_hands = poker_hands, before = true})
|
|
if effects.jokers then
|
|
card_eval_status_text(G.jokers.cards[i], 'jokers', nil, percent, nil, effects.jokers)
|
|
percent = percent + percent_delta
|
|
if effects.jokers.level_up then
|
|
level_up_hand(G.jokers.cards[i], text)
|
|
end
|
|
end
|
|
end'''
|
|
match_indent = true
|
|
position = "at"
|
|
payload = '''
|
|
-- context.before calculations
|
|
SMODS.calculate_context({full_hand = G.play.cards, scoring_hand = scoring_hand, scoring_name = text, poker_hands = poker_hands, before = true})
|
|
|
|
-- TARGET: effects before scoring starts'''
|
|
|
|
# context.final_scoring_step
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = "functions/state_events.lua"
|
|
pattern = '''local nu_chip, nu_mult = G.GAME.selected_back:trigger_effect{context = 'final_scoring_step', chips = hand_chips, mult = mult}'''
|
|
match_indent = true
|
|
position = "before"
|
|
payload = '''
|
|
-- context.final_scoring_step calculations
|
|
SMODS.calculate_context({full_hand = G.play.cards, scoring_hand = scoring_hand, scoring_name = text, poker_hands = poker_hands, final_scoring_step = true})
|
|
|
|
-- TARGET: effects before deck final_scoring_step
|
|
'''
|
|
|
|
# context.destroying_card
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = "functions/state_events.lua"
|
|
pattern = '''
|
|
for j = 1, #G.jokers.cards do
|
|
destroyed = G.jokers.cards[j]:calculate_joker({destroying_card = scoring_hand[i], full_hand = G.play.cards})
|
|
if destroyed then break end
|
|
end
|
|
|
|
if scoring_hand[i].ability.name == 'Glass Card' and not scoring_hand[i].debuff and pseudorandom('glass') < G.GAME.probabilities.normal/scoring_hand[i].ability.extra then
|
|
destroyed = true
|
|
end'''
|
|
match_indent = true
|
|
position = "at"
|
|
payload = '''
|
|
-- context.destroying_card calculations
|
|
for j = 1, #G.jokers.cards do
|
|
local eval, post = eval_card(G.jokers.cards[j], {destroying_card = scoring_hand[i], full_hand = G.play.cards})
|
|
SMODS.trigger_effects({eval, post}, scoring_hand[i])
|
|
if eval.jokers then destroyed = true end
|
|
|
|
end
|
|
|
|
if SMODS.has_enhancement(scoring_hand[i], 'm_glass') and not scoring_hand[i].debuff and pseudorandom('glass') < G.GAME.probabilities.normal/(scoring_hand[i].ability.name == 'Glass Card' and scoring_hand[i].ability.extra or G.P_CENTERS.m_glass.config.extra) then
|
|
destroyed = true
|
|
end
|
|
|
|
local eval, post = eval_card(scoring_hand[i], {destroying_card = scoring_hand[i], full_hand = G.play.cards, scoring_hand = scoring_hand, scoring_name = text, poker_hands = poker_hands, cardarea = G.play})
|
|
local self_destroy = false
|
|
for key, effect in pairs(eval) do
|
|
self_destroy = SMODS.calculate_effect(effect, scoring_hand[i])
|
|
end
|
|
SMODS.trigger_effects({post}, scoring_hand[i])
|
|
if self_destroy then destroyed = true end
|
|
|
|
-- TARGET: card destroyed when played
|
|
'''
|
|
|
|
# context.remove_playing_cards
|
|
[[patches]]
|
|
[patches.regex]
|
|
target = "functions/state_events.lua"
|
|
pattern = '''(?<indent>[\t ]*)local cards_destroyed = \{\}\n(.*\n)*?\s+for j=1, #G\.jokers\.cards do\n\s+eval_card\(G\.jokers\.cards\[j\], \{cardarea = G\.jokers, remove_playing_cards = true, removed = cards_destroyed\}\)\n\s+end'''
|
|
line_prepend = '$indent'
|
|
position = "at"
|
|
payload = '''
|
|
local cards_destroyed = {}
|
|
for _,v in ipairs(SMODS.get_card_areas('playing_cards', 'destroying_cards')) do
|
|
SMODS.calculate_destroying_cards({ full_hand = G.play.cards, scoring_hand = scoring_hand, scoring_name = text, poker_hands = poker_hands, cardarea = v }, cards_destroyed, v == G.play and scoring_hand or nil)
|
|
end
|
|
|
|
-- context.remove_playing_cards calculations
|
|
if cards_destroyed[1] then
|
|
SMODS.calculate_context({scoring_hand = scoring_hand, remove_playing_cards = true, removed = cards_destroyed})
|
|
end
|
|
|
|
-- TARGET: effects when cards are removed
|
|
|
|
'''
|
|
|
|
[[patches]]
|
|
[patches.regex]
|
|
target = 'card.lua'
|
|
line_prepend = '$indent'
|
|
position = 'at'
|
|
pattern = '(?<indent>[\t ]*)for i = 1, #G.jokers.cards do[\n\s]*G.jokers.cards\[i\]:calculate_joker\(\{remove_playing_cards = true, removed = destroyed_cards\}\)[\s\n]*end'
|
|
payload = '''SMODS.calculate_context({ remove_playing_cards = true, removed = destroyed_cards })'''
|
|
|
|
# context.remove_playing_cards from discard
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = "functions/state_events.lua"
|
|
pattern = '''
|
|
if destroyed_cards[1] then
|
|
for j=1, #G.jokers.cards do
|
|
eval_card(G.jokers.cards[j], {cardarea = G.jokers, remove_playing_cards = true, removed = destroyed_cards})
|
|
end
|
|
end
|
|
'''
|
|
position = "at"
|
|
match_indent = true
|
|
payload = '''
|
|
-- context.remove_playing_cards from discard
|
|
if destroyed_cards[1] then
|
|
SMODS.calculate_context({remove_playing_cards = true, removed = destroyed_cards})
|
|
end
|
|
|
|
-- TARGET: effects after cards destroyed in discard'''
|
|
|
|
|
|
# context.debuffed_hand
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = "functions/state_events.lua"
|
|
pattern = '''
|
|
for i=1, #G.jokers.cards do
|
|
|
|
--calculate the joker effects
|
|
local effects = eval_card(G.jokers.cards[i], {cardarea = G.jokers, full_hand = G.play.cards, scoring_hand = scoring_hand, scoring_name = text, poker_hands = poker_hands, debuffed_hand = true})
|
|
|
|
--Any Joker effects
|
|
if effects.jokers then
|
|
card_eval_status_text(G.jokers.cards[i], 'jokers', nil, percent, nil, effects.jokers)
|
|
percent = percent+percent_delta
|
|
end
|
|
end'''
|
|
match_indent = true
|
|
position = "at"
|
|
payload = '''
|
|
-- context.debuffed_hand calculations
|
|
SMODS.calculate_context({full_hand = G.play.cards, scoring_hand = scoring_hand, scoring_name = text, poker_hands = poker_hands, debuffed_hand = true})
|
|
|
|
-- TARGET: effects after hand debuffed by blind'''
|
|
|
|
# context.after
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = "functions/state_events.lua"
|
|
pattern = '''
|
|
for i=1, #G.jokers.cards do
|
|
--calculate the joker after hand played effects
|
|
local effects = eval_card(G.jokers.cards[i], {cardarea = G.jokers, full_hand = G.play.cards, scoring_hand = scoring_hand, scoring_name = text, poker_hands = poker_hands, after = true})
|
|
if effects.jokers then
|
|
card_eval_status_text(G.jokers.cards[i], 'jokers', nil, percent, nil, effects.jokers)
|
|
percent = percent + percent_delta
|
|
end
|
|
end'''
|
|
match_indent = true
|
|
position = "at"
|
|
payload = '''
|
|
-- context.after calculations
|
|
SMODS.calculate_context({full_hand = G.play.cards, scoring_hand = scoring_hand, scoring_name = text, poker_hands = poker_hands, after = true})
|
|
|
|
-- TARGET: effects after hand evaluation'''
|
|
|
|
# calc_dollar_bonus call through consumeables
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'functions/state_events.lua'
|
|
pattern = '''
|
|
for i = 1, #G.jokers.cards do
|
|
local ret = G.jokers.cards[i]:calculate_dollar_bonus()
|
|
if ret then
|
|
add_round_eval_row({dollars = ret, bonus = true, name='joker'..i, pitch = pitch, card = G.jokers.cards[i]})
|
|
pitch = pitch + 0.06
|
|
dollars = dollars + ret
|
|
end
|
|
end
|
|
'''
|
|
position = 'at'
|
|
match_indent = true
|
|
payload = '''
|
|
local i = 0
|
|
for _, area in ipairs(SMODS.get_card_areas('jokers')) do
|
|
for _, _card in ipairs(area.cards) do
|
|
local ret = _card:calculate_dollar_bonus()
|
|
|
|
-- TARGET: calc_dollar_bonus per card
|
|
if ret then
|
|
i = i+1
|
|
add_round_eval_row({dollars = ret, bonus = true, name='joker'..i, pitch = pitch, card = _card})
|
|
pitch = pitch + 0.06
|
|
dollars = dollars + ret
|
|
end
|
|
end
|
|
end
|
|
'''
|
|
|
|
# context.end_of_round
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'functions/state_events.lua'
|
|
pattern = '''
|
|
for i = 1, #G.jokers.cards do
|
|
local eval = nil
|
|
eval = G.jokers.cards[i]:calculate_joker({end_of_round = true, game_over = game_over})
|
|
if eval then
|
|
if eval.saved then
|
|
game_over = false
|
|
end
|
|
card_eval_status_text(G.jokers.cards[i], 'jokers', nil, nil, nil, eval)
|
|
end
|
|
G.jokers.cards[i]:calculate_rental()
|
|
G.jokers.cards[i]:calculate_perishable()
|
|
end
|
|
'''
|
|
position = 'at'
|
|
match_indent = true
|
|
payload = '''
|
|
-- context.end_of_round calculations
|
|
SMODS.saved = false
|
|
SMODS.calculate_context({end_of_round = true, game_over = game_over })
|
|
if SMODS.saved then game_over = false end
|
|
-- TARGET: main end_of_round evaluation
|
|
'''
|
|
|
|
# context.end_of_round individual effects
|
|
[[patches]]
|
|
[patches.regex]
|
|
target = 'functions/state_events.lua'
|
|
position = 'at'
|
|
pattern = '''(?<indent>[\t ]*)for i=1, #G\.hand\.cards do\n\s+--Check for hand doubling\n(.*\n)*?\s+delay\(0\.3\)'''
|
|
line_prepend = '$indent'
|
|
payload = '''for _,v in ipairs(SMODS.get_card_areas('playing_cards', 'end_of_round')) do
|
|
SMODS.calculate_end_of_round_effects({ cardarea = v, end_of_round = true })
|
|
end
|
|
'''
|
|
|
|
|
|
# context.setting_blind
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'functions/state_events.lua'
|
|
pattern = '''
|
|
for i = 1, #G.jokers.cards do
|
|
G.jokers.cards[i]:calculate_joker({setting_blind = true, blind = G.GAME.round_resets.blind})
|
|
end
|
|
'''
|
|
position = 'at'
|
|
match_indent = true
|
|
payload = '''
|
|
SMODS.calculate_context({setting_blind = true, blind = G.GAME.round_resets.blind})
|
|
|
|
-- TARGET: setting_blind effects
|
|
'''
|
|
|
|
# context.pre_discard
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'functions/state_events.lua'
|
|
pattern = '''
|
|
for j = 1, #G.jokers.cards do
|
|
G.jokers.cards[j]:calculate_joker({pre_discard = true, full_hand = G.hand.highlighted, hook = hook})
|
|
end
|
|
'''
|
|
position = 'at'
|
|
match_indent = true
|
|
payload = '''
|
|
SMODS.calculate_context({pre_discard = true, full_hand = G.hand.highlighted, hook = hook})
|
|
|
|
-- TARGET: pre_discard
|
|
'''
|
|
|
|
# context.selling_self in cards
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'card.lua'
|
|
pattern = '''
|
|
self:calculate_joker{selling_self = true}
|
|
'''
|
|
position = 'at'
|
|
match_indent = true
|
|
payload = '''
|
|
local eval, post = eval_card(self, {selling_self = true})
|
|
SMODS.trigger_effects({eval, post}, self)
|
|
'''
|
|
|
|
# context.open_booster
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'card.lua'
|
|
pattern = '''
|
|
for i = 1, #G.jokers.cards do
|
|
G.jokers.cards[i]:calculate_joker({open_booster = true, card = self})
|
|
end
|
|
'''
|
|
position = 'at'
|
|
match_indent = true
|
|
payload = '''
|
|
SMODS.calculate_context({open_booster = true, card = self})
|
|
'''
|
|
|
|
# context.buying_card
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'card.lua'
|
|
pattern = '''
|
|
for i = 1, #G.jokers.cards do
|
|
G.jokers.cards[i]:calculate_joker({buying_card = true, card = self})
|
|
end
|
|
'''
|
|
position = 'at'
|
|
match_indent = true
|
|
payload = '''
|
|
SMODS.calculate_context({buying_card = true, card = self})
|
|
'''
|
|
|
|
# context.first_hand_drawn
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'game.lua'
|
|
pattern = '''
|
|
for i = 1, #G.jokers.cards do
|
|
G.jokers.cards[i]:calculate_joker({first_hand_drawn = true})
|
|
end
|
|
end
|
|
'''
|
|
position = 'at'
|
|
match_indent = true
|
|
payload = '''
|
|
SMODS.calculate_context({first_hand_drawn = true})
|
|
end
|
|
SMODS.calculate_context({hand_drawn = true})
|
|
'''
|
|
|
|
# context.using_consumeable
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'functions/button_callbacks.lua'
|
|
pattern = '''
|
|
for i = 1, #G.jokers.cards do
|
|
G.jokers.cards[i]:calculate_joker({using_consumeable = true, consumeable = card})
|
|
end
|
|
'''
|
|
position = 'at'
|
|
match_indent = true
|
|
payload = '''
|
|
SMODS.calculate_context({using_consumeable = true, consumeable = card, area = card.from_area})
|
|
'''
|
|
# save area of used card
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'functions/button_callbacks.lua'
|
|
match_indent = true
|
|
position = 'before'
|
|
pattern = '''
|
|
c1.area:remove_card(c1)
|
|
'''
|
|
payload = '''
|
|
c1.from_area = c1.area
|
|
'''
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'functions/button_callbacks.lua'
|
|
match_indent = true
|
|
position = 'before'
|
|
pattern = '''
|
|
if card.area and (not nc or card.area == G.pack_cards) then card.area:remove_card(card) end
|
|
'''
|
|
payload = '''
|
|
if not card.from_area then card.from_area = card.area end
|
|
'''
|
|
|
|
# context.selling_card
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'functions/button_callbacks.lua'
|
|
pattern = '''
|
|
for i = 1, #G.jokers.cards do
|
|
if G.jokers.cards[i] ~= card then
|
|
G.jokers.cards[i]:calculate_joker({selling_card = true, card = card})
|
|
end
|
|
end
|
|
'''
|
|
position = 'at'
|
|
match_indent = true
|
|
payload = '''
|
|
SMODS.calculate_context({selling_card = true, card = card})
|
|
'''
|
|
|
|
|
|
# context.buying_card
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'functions/button_callbacks.lua'
|
|
pattern = '''
|
|
G.E_MANAGER:add_event(Event({func = function() c1:calculate_joker({buying_card = true, card = c1}) return true end}))
|
|
'''
|
|
position = 'at'
|
|
match_indent = true
|
|
payload = '''
|
|
G.E_MANAGER:add_event(Event({func = function()
|
|
local eval, post = eval_card(c1, {buying_card = true, card = c1})
|
|
SMODS.trigger_effects({eval, post}, c1)
|
|
return true
|
|
end}))
|
|
'''
|
|
|
|
# context.buying_card
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'functions/button_callbacks.lua'
|
|
pattern = '''
|
|
for i = 1, #G.jokers.cards do
|
|
G.jokers.cards[i]:calculate_joker({buying_card = true, card = c1})
|
|
end
|
|
'''
|
|
position = 'at'
|
|
match_indent = true
|
|
payload = '''
|
|
SMODS.calculate_context({buying_card = true, card = c1})
|
|
'''
|
|
|
|
# context.ending_shop
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'functions/button_callbacks.lua'
|
|
pattern = '''
|
|
for i = 1, #G.jokers.cards do
|
|
G.jokers.cards[i]:calculate_joker({ending_shop = true})
|
|
end
|
|
'''
|
|
position = 'at'
|
|
match_indent = true
|
|
payload = '''
|
|
SMODS.calculate_context({ending_shop = true})
|
|
'''
|
|
|
|
# context.skipping_booster
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'functions/button_callbacks.lua'
|
|
pattern = '''
|
|
for i = 1, #G.jokers.cards do
|
|
G.jokers.cards[i]:calculate_joker({skipping_booster = true})
|
|
end
|
|
'''
|
|
position = 'at'
|
|
match_indent = true
|
|
payload = '''
|
|
SMODS.calculate_context({skipping_booster = true})
|
|
'''
|
|
# context.skip_blind
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'functions/button_callbacks.lua'
|
|
pattern = '''
|
|
for i = 1, #G.jokers.cards do
|
|
G.jokers.cards[i]:calculate_joker({skip_blind = true})
|
|
end
|
|
'''
|
|
position = 'at'
|
|
match_indent = true
|
|
payload = '''
|
|
SMODS.calculate_context({skip_blind = true})
|
|
'''
|
|
|
|
# context.reroll_shop
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'functions/button_callbacks.lua'
|
|
pattern = '''
|
|
for i = 1, #G.jokers.cards do
|
|
G.jokers.cards[i]:calculate_joker({reroll_shop = true})
|
|
end
|
|
'''
|
|
position = 'at'
|
|
match_indent = true
|
|
payload = '''
|
|
SMODS.calculate_context({reroll_shop = true})
|
|
'''
|
|
|
|
|
|
# Fix purple seal calc
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'card.lua'
|
|
pattern = '''
|
|
if context.discard then
|
|
if self.seal == 'Purple' and #G.consumeables.cards + G.GAME.consumeable_buffer < G.consumeables.config.card_limit then'''
|
|
position = 'at'
|
|
match_indent = true
|
|
payload = '''
|
|
if context.discard and context.other_card == self then
|
|
if self.seal == 'Purple' and #G.consumeables.cards + G.GAME.consumeable_buffer < G.consumeables.config.card_limit then'''
|
|
|
|
# Fix context.blueprint persisting
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'card.lua'
|
|
match_indent = true
|
|
position = 'after'
|
|
pattern = 'local other_joker_ret = other_joker:calculate_joker(context)'
|
|
payload = '''
|
|
context.blueprint = nil
|
|
local eff_card = context.blueprint_card or self
|
|
context.blueprint_card = nil'''
|
|
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'card.lua'
|
|
match_indent = true
|
|
position = 'at'
|
|
pattern = 'other_joker_ret.card = context.blueprint_card or self'
|
|
payload = '''other_joker_ret.card = eff_card'''
|
|
|
|
# Auto deal with negative chips card_eval_status_text()
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'functions/common_events.lua'
|
|
match_indent = true
|
|
position = 'at'
|
|
pattern = '''
|
|
text = localize{type='variable',key='a_chips',vars={amt}}
|
|
'''
|
|
payload = '''
|
|
text = localize{type='variable',key='a_chips'..(amt<0 and '_minus' or ''),vars={math.abs(amt)}}
|
|
'''
|
|
|
|
# Auto deal with negative mult card_eval_status_text()
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'functions/common_events.lua'
|
|
match_indent = true
|
|
position = 'at'
|
|
pattern = '''
|
|
text = localize{type='variable',key='a_mult',vars={amt}}
|
|
'''
|
|
payload = '''
|
|
text = localize{type='variable',key='a_mult'..(amt<0 and '_minus' or ''),vars={math.abs(amt)}}
|
|
'''
|
|
|
|
# Auto deal with negative xmult card_eval_status_text()
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'functions/common_events.lua'
|
|
match_indent = true
|
|
position = 'at'
|
|
pattern = '''
|
|
text = localize{type='variable',key='a_xmult',vars={amt}}
|
|
'''
|
|
payload = '''
|
|
text = localize{type='variable',key='a_xmult'..(amt<0 and '_minus' or ''),vars={math.abs(amt)}}
|
|
'''
|
|
# Make percent and percent_delta globals
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'functions/state_events.lua'
|
|
match_indent = true
|
|
position = 'at'
|
|
pattern = '''local percent = 0.3
|
|
local percent_delta = 0.08
|
|
'''
|
|
payload = '''percent = 0.3
|
|
percent_delta = 0.08
|
|
'''
|
|
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'functions/state_events.lua'
|
|
match_indent = true
|
|
position = 'at'
|
|
pattern = '''local percent = (i-0.999)/(#G.hand.cards-0.998) + (j-1)*0.1'''
|
|
payload = '''percent = (i-0.999)/(#G.hand.cards-0.998) + (j-1)*0.1'''
|
|
|
|
# Add support for pitch and volume returns in effects
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'functions/common_events.lua'
|
|
match_indent = true
|
|
position = 'after'
|
|
pattern = '''
|
|
volume = extra.edition and 0.3 or sound == 'multhit2' and 0.7 or 1
|
|
'''
|
|
payload = '''
|
|
sound = extra.sound or sound
|
|
percent = extra.pitch or percent
|
|
volume = extra.volume or volume
|
|
'''
|
|
|
|
# Voucher cardarea
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'game.lua'
|
|
match_indent = true
|
|
position = 'before'
|
|
pattern = 'self.deck = CardArea('
|
|
payload = '''self.vouchers = CardArea(
|
|
G.discard.T.x, G.discard.T.y,
|
|
G.discard.T.w, G.discard.T.h,
|
|
{ type = "discard", card_limit = 1e308 }
|
|
)
|
|
'''
|
|
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'card.lua'
|
|
match_indent = true
|
|
position = 'after'
|
|
pattern = 'function Card:apply_to_run(center)'
|
|
payload = '''local card_to_save = self and copy_card(self) or Card(0, 0, G.CARD_W, G.CARD_H, G.P_CARDS.empty, center)
|
|
card_to_save.VT.x, card_to_save.VT.y = G.vouchers.T.x, G.vouchers.T.y
|
|
G.vouchers:emplace(card_to_save)
|
|
'''
|
|
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'card.lua'
|
|
position = 'at'
|
|
match_indent = false
|
|
pattern = '''if self.ability.set == "Planet" and not self.debuff then
|
|
if context.joker_main then
|
|
if G.GAME.used_vouchers.v_observatory and self.ability.consumeable.hand_type == context.scoring_name then
|
|
return {
|
|
message = localize{type = 'variable', key = 'a_xmult', vars = {G.P_CENTERS.v_observatory.config.extra}},
|
|
Xmult_mod = G.P_CENTERS.v_observatory.config.extra
|
|
}
|
|
end
|
|
end
|
|
end'''
|
|
payload = ''
|
|
|
|
[[patches]]
|
|
[patches.regex]
|
|
target = 'back.lua'
|
|
position = 'at'
|
|
line_prepend = '$indent'
|
|
pattern = '(?<indent>[\t ]*)(?<line>Card.apply_to_run\(nil, G\.P_CENTERS\[.*?\]\))'
|
|
payload = '''G.E_MANAGER:add_event(Event({
|
|
func = function()
|
|
$line
|
|
return true
|
|
end
|
|
}))'''
|
|
|
|
#wtf
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'card.lua'
|
|
match_indent = true
|
|
position = 'at'
|
|
pattern = '''self.discard_pos = {
|
|
r = 3.6*(math.random()-0.5),
|
|
x = math.random(),
|
|
y = math.random()
|
|
}'''
|
|
payload = '''self.discard_pos = {
|
|
r = 0,
|
|
x = 0,
|
|
y = 0,
|
|
}
|
|
'''
|
|
|
|
# xchip support
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'functions/common_events.lua'
|
|
match_indent = true
|
|
position = 'before'
|
|
pattern = '''
|
|
elseif (eval_type == 'x_mult') or (eval_type == 'h_x_mult') then
|
|
'''
|
|
payload = '''
|
|
elseif eval_type == 'x_chips' then
|
|
sound = 'xchips'
|
|
volume = 0.7
|
|
amt = amt
|
|
text = localize{type='variable',key='a_xchips'..(amt<0 and '_minus' or ''),vars={math.abs(amt)}}
|
|
colour = G.C.BLUE
|
|
config.type = 'fade'
|
|
config.scale = 0.7
|
|
'''
|
|
[[patches]]
|
|
[patches.pattern]
|
|
target = 'functions/common_events.lua'
|
|
match_indent = true
|
|
position = 'at'
|
|
pattern = '''
|
|
if extra.chip_mod then
|
|
'''
|
|
payload = '''
|
|
if extra.chip_mod or extra.Xchip_mod then
|
|
'''
|