lovely.toml

[manifest]
version = "1.0.0"
dump_lua = true
priority = 0

# Exotics toggle
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = 'G.GAME.hands[text].played = G.GAME.hands[text].played + 1'
position = 'after'
match_indent = true
payload = '''

if text == 'bunc_Spectrum'
or text == 'bunc_Straight Spectrum'
or text == 'bunc_Spectrum House'
or text == 'bunc_Spectrum Five' then
    enable_exotics()
    unlock_card(G.P_CENTERS.b_bunc_fairy)
end

'''

# Exotic color, part 1/2
[[patches]]
[patches.pattern]
target = 'globals.lua'
pattern = "RENTAL = HEX('b18f43'),"
position = 'after'
match_indent = true
payload = '''BUNCO_EXOTIC = HEX('ef9ae7'),'''

# Exotic color, part 2/2
[[patches]]
[patches.pattern]
target = 'functions/misc_functions.lua'
pattern = "legendary = G.C.RARITY[4],"
position = 'after'
match_indent = true
payload = '''bunco_exotic = G.C.BUNCO_EXOTIC,'''

# Colorful Finishers, part 1/4
[[patches]]
[patches.pattern]
target = 'functions/common_events.lua'
pattern = "function ease_background_colour_blind(state, blind_override)"
position = 'before'
match_indent = true
payload = '''

local function invert_color(color, invert_red, invert_green, invert_blue)
    local inverted_color = {
    1 - (color[1] or 0),
    1 - (color[2] or 0),
    1 - (color[3] or 0),
    color[4] or 1
    }

    if invert_red then
        inverted_color[1] = color[1] or 0
    end
    if invert_green then
        inverted_color[2] = color[2] or 0
    end
    if invert_blue then
        inverted_color[3] = color[3] or 0
    end

    return inverted_color
end

local function increase_saturation(color, value)
    -- Extract RGB components
    local r = color[1] or 0
    local g = color[2] or 0
    local b = color[3] or 0

    -- Convert RGB to HSL
    local max_val = math.max(r, g, b)
    local min_val = math.min(r, g, b)
    local delta = max_val - min_val

    local h, s, l = 0, 0, (max_val + min_val) / 2

    if delta ~= 0 then
        if l < 0.5 then
            s = delta / (max_val + min_val)
        else
            s = delta / (2 - max_val - min_val)
        end

        if r == max_val then
            h = (g - b) / delta
        elseif g == max_val then
            h = 2 + (b - r) / delta
        else
            h = 4 + (r - g) / delta
        end

        h = h * 60
        if h < 0 then
            h = h + 360
        end
    end

    -- Increase saturation
    s = math.min(s + value, 1)

    -- Convert back to RGB
    local c = (1 - math.abs(2 * l - 1)) * s
    local x = c * (1 - math.abs((h / 60) % 2 - 1))
    local m = l - c / 2

    local r_new, g_new, b_new = 0, 0, 0

    if h < 60 then
        r_new, g_new, b_new = c, x, 0
    elseif h < 120 then
        r_new, g_new, b_new = x, c, 0
    elseif h < 180 then
        r_new, g_new, b_new = 0, c, x
    elseif h < 240 then
        r_new, g_new, b_new = 0, x, c
    elseif h < 300 then
        r_new, g_new, b_new = x, 0, c
    else
        r_new, g_new, b_new = c, 0, x
    end

    -- Adjust RGB values
    r_new, g_new, b_new = (r_new + m), (g_new + m), (b_new + m)

    return {r_new, g_new, b_new, color[4] or 1}
end

'''

# Colorful Finishers, part 2/4
[[patches]]
[patches.pattern]
target = 'functions/common_events.lua'
pattern = "if v.name == blindname then"
position = 'after'
match_indent = true
payload = '''
boss_col = v.boss_colour
'''
# Colorful Finishers, part 3/4
[[patches]]
[patches.pattern]
target = 'functions/common_events.lua'
pattern = "ease_background_colour{new_colour = G.C.BLUE, special_colour = G.C.RED, tertiary_colour = darken(G.C.BLACK, 0.4), contrast = 3}"
position = 'at'
match_indent = true
payload = '''

if BUNCOMOD.content.config.colorful_finishers then
    ease_background_colour{new_colour = increase_saturation(mix_colours(boss_col, invert_color(boss_col), 0.3), 1),
    special_colour = boss_col,
    tertiary_colour = darken(increase_saturation(mix_colours(boss_col, invert_color(boss_col, true, false, false), 0.3), 0.6), 0.4), contrast = 1.7}
else
    ease_background_colour{new_colour = G.C.BLUE, special_colour = G.C.RED, tertiary_colour = darken(G.C.BLACK, 0.4), contrast = 3}
end

'''

# Colorful Finishers, part 4/4
[[patches]]
[patches.pattern]
target = 'functions/common_events.lua'
pattern = 'elseif G.GAME.won then'
position = 'at'
match_indent = true
payload = '''elseif G.GAME.won and not BUNCOMOD.content.config.colorful_finishers then'''

# Luchador Rework
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = "elseif self.ability.name == 'Luchador' then"
position = 'at'
match_indent = true
payload = '''elseif self.ability.name == 'Luchador' and not BUNCOMOD.content.config.gameplay_reworks then'''

# Red Card Rework
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = "if self.ability.name == 'Red Card' and not context.blueprint then"
position = 'at'
match_indent = true
payload = '''if self.ability.name == 'Red Card' and not context.blueprint and not BUNCOMOD.content.config.gameplay_reworks then'''

# Boss Tag Rework
[[patches]]
[patches.pattern]
target = 'tag.lua'
pattern = "if self.name == 'Boss Tag' then"
position = 'at'
match_indent = true
payload = '''if self.name == 'Boss Tag' and not BUNCOMOD.content.config.gameplay_reworks then'''

# # Shiny Blinds
# [[patches]]
# [patches.pattern]
# target = 'blind.lua'
# pattern = "self.children.animatedSprite:draw_shader('dissolve', 0.1)"
# position = 'at'
# match_indent = true
# payload = '''

# self.ARGS.send_to_shader = self.ARGS.send_to_shader or {}
# self.ARGS.send_to_shader[1] = self.children.animatedSprite.VT.r*10 + G.TIMERS.REAL/(28) + (self.children.animatedSprite.juice and self.children.animatedSprite.juice.r*10 or 0) + self.tilt_var.amt
# self.ARGS.send_to_shader[2] = G.TIMERS.REAL
# self.children.animatedSprite:draw_shader('polychrome', 0.1, self.ARGS.send_to_shader)

# '''
# # Shiny Blinds
# [[patches]]
# [patches.pattern]
# target = 'blind.lua'
# pattern = "self.children.animatedSprite:draw_shader('dissolve')"
# position = 'at'
# match_indent = true
# payload = '''

# self.children.animatedSprite:draw_shader('polychrome', nil, self.ARGS.send_to_shader)

# '''

# # Shiny Blinds
# [[patches]]
# [patches.pattern]
# target = 'functions\UI_definitions.lua'
# pattern = "{shader = 'dissolve', shadow_height = 0.05}"
# position = 'at'
# match_indent = true
# payload = '''
# {shader = 'polychrome', shadow_height = 0.05}
# '''

# function generate_card_ui() (Temporary extra chips)
[[patches]]
[patches.pattern]
target = "functions/common_events.lua"
pattern = "if main_end then"
position = "before"
match_indent = true
payload = '''
if (_c.set == 'Default' or _c.set == 'Enhanced') and card and card.ability and type(card.ability) == 'table' and card.ability.temporary_extra_chips and not card.debuff then
    localize{type = 'other', key = 'temporary_extra_chips', nodes = desc_nodes, vars = {card.ability.temporary_extra_chips}}
end'''

# Linked cards selection 1/2
[[patches]]
[patches.pattern]
target = 'cardarea.lua'
pattern = 'function CardArea:can_highlight(card)'
position = 'after'
match_indent = true
payload = '''

-- Making so the player can't choose a group of linked cards if it'd bypass highlighted limit

if card and card.ability.group then

    local group_amount = 0 -- Amount of cards in the same group
    local highlighted_amount = 0 -- Amount of cards already highlighted
    local highlighted_group_amount = 0 -- Amount of cards already highlighted in the same group

    for i = 1, #self.cards do
        if self.cards[i].ability.group and self.cards[i].ability.group.id == card.ability.group.id then
            if not self.cards[i].highlighted then
                group_amount = group_amount + 1
            else
                highlighted_group_amount = highlighted_group_amount + 1
            end
        end
        if self.cards[i].highlighted then
            highlighted_amount = highlighted_amount + 1
        end
    end


    -- If you select a group that has more cards than the game allows
    if (not card.highlighted) and (group_amount > self.config.highlighted_limit) then

        -- Check if there's already cards selected
        if highlighted_amount ~= 0 then
            return false
        end

        return true
    end

    -- If you select a normal amount of cards but the amount of cards in the group and already highlighted will bypass the limit
    if (not card.highlighted) and (self.config.highlighted_limit < (group_amount + highlighted_amount)) then
        return false
    end

    -- If you want to unselect cards that already bypassed the limit
    if card.highlighted then
        return true
    end
end

'''

# Linked cards selection 2/2
[[patches]]
[patches.pattern]
target = 'cardarea.lua'
pattern = 'if #self.highlighted >= self.config.highlighted_limit then'
position = 'at'
match_indent = true
payload = '''if (#self.highlighted >= self.config.highlighted_limit) and (not card.ability.group) then'''

# Linked cards destruction 1/2
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = 'self.removed = true'
position = 'before'
match_indent = true
payload = '''

local grouped, grouped_area_cards
if self.ability.group then
    grouped = self
    grouped_area_cards = self.area and self.area.cards or nil
end

'''

# Linked cards destruction 2/2
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = 'Moveable.remove(self)'
position = 'after'
match_indent = true
payload = '''

G.E_MANAGER:add_event(Event({blocking = false, trigger = 'after', func = function()
    if grouped and grouped_area_cards and #grouped_area_cards > 0 then

        local next_card
        local destroyed_cards = {}
        for i=1, #grouped_area_cards do
            if grouped_area_cards[i].ability.group and grouped_area_cards[i].ability.group then
                if grouped_area_cards[i].ability.group.id == grouped.ability.group.id then
                    table.insert(destroyed_cards, grouped_area_cards[i])
                end
            end
        end

        next_card = destroyed_cards[1]

        if next_card then
            if next_card.ability.name == 'Glass Card' then
                next_card:shatter()
            else
                next_card:start_dissolve()
            end

            for i = 1, #G.jokers.cards do
                eval_card(G.jokers.cards[i], {
                    cardarea = G.jokers,
                    remove_playing_cards = true,
                    removed = {next_card}
                })
            end
        end
    end
return true end}))

'''

# Linked cards description
[[patches]]
[patches.pattern]
target = "functions/common_events.lua"
pattern = "if main_end then"
position = "before"
match_indent = true
payload = '''
if (_c.set == 'Default' or _c.set == 'Enhanced') and card and card.ability and type(card.ability) == 'table' and card.ability.group then
    localize{type = 'other', key = card.greyed and 'drawn_linked_cards' or 'linked_cards', nodes = desc_nodes, vars = {}}
    if not (card.area.config.type == 'title' and card.greyed) then
        main_end = main_end or {}
        local all_cards_from_group = {}
        if card and card.area then
            if card.area.config.type == 'title' then
                for i = 1, #G.deck.cards do
                    local check_card = G.deck.cards[i]
                    if check_card.ability and type(check_card.ability) == 'table' and check_card.ability.group then
                        if check_card.ability.group.id == card.ability.group.id then
                            table.insert(all_cards_from_group, check_card)
                        end
                    end
                end
            else
                for i = 1, #card.area.cards do
                    local check_card = card.area.cards[i]
                    if check_card.ability and type(check_card.ability) == 'table' and check_card.ability.group then
                        if check_card.ability.group.id == card.ability.group.id then
                            table.insert(all_cards_from_group, check_card)
                        end
                    end
                end
            end
        end
        local cardarea = CardArea(
            0,
            0,
            2.85 * G.CARD_W,
            0.75 * G.CARD_H,
            {card_limit = #all_cards_from_group, type = 'title', highlight_limit = 0}
        )
        for k, v in ipairs(all_cards_from_group) do
            local group_card = copy_card(v, nil, 0.5)
            group_card.states.hover.can = false
            group_card:juice_up(0.3, 0.2)
            if k == 1 then play_sound('paper1', 0.95 + math.random() * 0.1, 0.3) end
            ease_value(group_card.T, 'scale', 0.25, nil, 'REAL', true, 0.2)
            cardarea:emplace(group_card)
        end
        table.insert(main_end, {n=G.UIT.R, config = {align = "cm", colour = G.C.CLEAR, r = 0.0}, nodes={
            {n=G.UIT.C, config = {align = "cm"}, nodes={
                {n=G.UIT.O, config = {object = cardarea}}
            }}
        }})
    end
end'''

# Linked cards undiscovered sprite
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = '''local shared_sprite = (self.ability.set == 'Edition' or self.ability.set == 'Joker') and G.shared_undiscovered_joker or G.shared_undiscovered_tarot'''
position = 'after'
match_indent = true
payload = '''

if not G.shared_undiscovered_polymino then G.shared_undiscovered_polymino = Sprite(0, 0, G.CARD_W, G.CARD_H, G.ASSET_ATLAS['bunc_bunco_polyminoes_undiscovered'], {x = 1, y = 0}) end

if self.ability.set == 'Polymino' then
    shared_sprite = G.shared_undiscovered_polymino
end

'''

[[patches]]
[patches.pattern]
target = 'functions/button_callbacks.lua'
pattern = 'if #G.hand.highlighted <= 0 or G.GAME.blind.block_play or #G.hand.highlighted > 5 then'
position = 'at'
match_indent = true
payload = '''

local group_size = 0

if G.hand and G.hand.highlighted then
    for i = 1, #G.hand.highlighted do
        if G.hand.highlighted[i].ability.group then
            group_size = group_size + 1
        end
    end
end

if #G.hand.highlighted <= (G.GAME.blind and G.GAME.blind.name == 'cry-Sapphire Stamp' and not G.GAME.blind.disabled and 1 or 0) or G.GAME.blind.block_play or (#G.hand.highlighted > G.hand.config.highlighted_limit and group_size <= G.hand.config.highlighted_limit) then

'''

# Linked cards visual cue
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = '''if self.greyed then'''
position = 'before'
match_indent = true
payload = '''

if self.ability.group then
    if not self.children.link then
        local variant = self.ability.group.id
        variant = 1 + (variant - 1) % 5
        self.children.link = Sprite(self.T.x, self.T.y, self.T.w, self.T.h, G.ASSET_ATLAS['bunc_bunco_link'], {x = variant - 1, y = 0})
        self.children.link.states.visible = false
    end
    self.children.link:draw_shader('dissolve', nil, nil, nil, self.children.center, 0, 0)
    self.children.link.role.draw_major = self
end

'''

# Virtual pack deck alignment
[[patches]]
[patches.pattern]
target = 'cardarea.lua'
pattern = '''if self.children.view_deck then'''
position = 'before'
match_indent = true
payload = '''

if self.config.type == 'hand' and G.hand and G.STATE == G.STATES.SMODS_BOOSTER_OPENED and SMODS.OPENED_BOOSTER.config.center.type == 'bunc_virtual' then
    G.hand:sort()
    for i = 1, #G.hand.cards do
        local card = G.hand.cards[i]
        card.states.drag.can = false

        local offset_mult = 0.4

        card.T.y = card.T.y - (
            card.base.suit == 'Spades' and offset_mult * 2
        or card.base.suit == 'Hearts' and offset_mult * 1
        or card.base.suit == 'Clubs' and offset_mult * 0
        or card.base.suit == 'Diamonds' and offset_mult * -1
        or card.base.suit == 'bunc_Fleurons' and offset_mult * -2
        or card.base.suit == 'bunc_Halberds' and offset_mult * -3
        or offset_mult * -4)

        local align_mult = 0.2

        card.T.x = card.T.x - (
            card.base.suit == 'Spades' and 0.0
        or card.base.suit == 'Hearts' and align_mult
        or card.base.suit == 'Clubs' and align_mult * 2
        or card.base.suit == 'Diamonds' and align_mult * 3
        or card.base.suit == 'bunc_Fleurons' and align_mult * 4
        or card.base.suit == 'bunc_Halberds' and align_mult * 5
        or align_mult * 6)

        card.T.r = card.T.r / 3.0
        if card.highlighted then
            card.T.y = card.T.y + 0.5
            card.greyed = false
        else
            card.greyed = true
        end
    end
end

'''

# Linked cards saving (experimental)
[[patches]]
[patches.pattern]
target = 'functions/common_events.lua'
pattern = '''play_sound('card1', 0.85 + percent*0.2/100, 0.6*(vol or 1))'''
position = 'after'
match_indent = true
payload = '''

G.E_MANAGER:add_event(Event({blocking = false, trigger = 'after', func = function()
    if card and card.ability and card.ability.group then
        save_run()
    end
    return true
end}))

'''

# function Card:flip() (Cassette)
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = "self.facing='back'"
position = 'after'
match_indent = true
payload = '''

if self.config.center.key == 'j_bunc_cassette' then
    self:flip()
    self:calculate_joker({flip = true})
end

'''

# function CardArea:emplace() (X-Ray)
[[patches]]
[patches.pattern]
target = 'cardarea.lua'
pattern = 'if #self.cards > self.config.card_limit then'
position = 'before'
match_indent = true
payload = '''

if G.jokers ~= nil and self == G.hand then
    for _, v in ipairs(G.jokers.cards) do
        if v.config.center.key == 'j_bunc_xray' then
            v:calculate_joker({emplaced_card = card})
        end
    end
end

'''

# function copy_card (Dread)
[[patches]]
[patches.pattern]
target = 'functions/common_events.lua'
pattern = 'if not strip_edition then'
position = 'before'
match_indent = true
payload = '''

if new_card.config.center.key == 'j_bunc_dread' then
    new_card.ability.extra.level_up_list = {}
end

'''

# function Card:set_cost() (Loan Shark)
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = 'if self.area and self.ability.couponed and (self.area == G.shop_jokers or self.area == G.shop_booster) then self.cost = 0 end'
position = 'after'
match_indent = true
payload = '''

if self.config.center.key == 'j_bunc_loan_shark' and self.added_to_deck then
    self.sell_cost = self.ability.extra.cost + (self.ability.extra_value or 0)
end

'''

# Joker Knight variables
[[patches]]
[patches.pattern]
target = 'engine/node.lua'
pattern = 'function Node:drag()'
position = 'before'
match_indent = true
payload = '''

local break_table = {before = nil, after = nil, node = nil}

'''

# function Node:drag() (Joker Knight 1/2)
[[patches]]
[patches.pattern]
target = 'engine/node.lua'
pattern = 'function Node:drag()'
position = 'after'
match_indent = true
payload = '''

if G.jokers ~= nil and self:is(Card) and self.area == G.jokers then
    for _, v in ipairs(G.jokers.cards) do
        if v.config.center.key == 'j_bunc_knight' and not v.debuff then
            if break_table.before == nil then

                break_table.before = {}

                for _, v in ipairs(G.jokers.cards) do
                    table.insert(break_table.before, v.ability.name)
                end

                break_table.after = break_table.before
                break_table.node = self

            end
        end
    end
end

'''

# function Node:stop_drag() (Joker Knight 2/2)
[[patches]]
[patches.pattern]
target = 'engine/node.lua'
pattern = 'function Node:stop_drag()'
position = 'after'
match_indent = true
payload = '''

if G.jokers ~= nil and self == break_table.node then
    for _, v in ipairs(G.jokers.cards) do
        if v.config.center.key == 'j_bunc_knight' and not v.debuff then
            function do_tables_match(a, b)
                return table.concat(a) == table.concat(b)
            end

            if break_table.before ~= nil then

            break_table.before = {}

            for _, v in ipairs(G.jokers.cards) do
                table.insert(break_table.before, v.ability.name)
            end

            if not do_tables_match(break_table.before, break_table.after) then
                v:calculate_joker({ break_positions = true })
            end

                break_table.before = nil
                break_table.after = nil

            end
        end
    end
end

'''

# function create_card() (JMJB)
[[patches]]
[patches.pattern]
target = 'functions/common_events.lua'
pattern = 'card:set_edition(edition)'
position = 'before'
match_indent = true
payload = '''if card.config.center.key == 'j_bunc_jmjb' then edition = poll_edition(nil, nil, true, true) end'''

# function ease_dollars() (Fiendish)
[[patches]]
[patches.pattern]
target = 'functions/common_events.lua'
pattern = 'function ease_dollars(mod, instant)'
position = 'after'
match_indent = true
payload = '''

if G.jokers ~= nil then
    for _, v in ipairs(G.jokers.cards) do
        if v.config.center.key == 'j_bunc_fiendish' and not v.debuff then
            if mod > 0 then
                if pseudorandom('fiendish'..G.SEED) < G.GAME.probabilities.normal / v.ability.extra.odds then
                    mod = 1
                    card_eval_status_text(
                    v,
                    'extra',
                    nil, nil, nil,
                    {message = '$'..(mod or '1'), colour = G.C.RED, instant = true})
                else
                    mod = mod * 2
                    card_eval_status_text(
                    v,
                    'extra',
                    nil, nil, nil,
                    {message = '$'..mod, colour = G.C.ORANGE, instant = true})
                end
            end
        end
    end
end

'''

# function create_card() (Doorhanger)
[[patches]]
[patches.pattern]
target = 'functions/common_events.lua'
pattern = 'local _pool, _pool_key = get_current_pool(_type, _rarity, legendary, key_append)'
position = 'before'
match_indent = true
payload = '''

if G.jokers ~= nil then
    for _, v in ipairs(G.jokers.cards) do
        if v.config.center.key == 'j_bunc_doorhanger' and not v.debuff then
            if _rarity == nil or _rarity < 0.9 then

                _rarity = 0.9

                if pseudorandom('doorhanger'..G.SEED) > 0.98 then
                    _rarity = 1
                end
            end
        end
    end
end

'''

# function evaluate_play (Nil Bill, Neon)
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = "card_eval_status_text(scoring_hand[i], 'debuff')"
position = 'after'
match_indent = true
payload = '''

if G.jokers ~= nil then
    for _, v in ipairs(G.jokers.cards) do
        if (v.config.center.key == 'j_bunc_nil_bill' or v.config.center.key == 'j_bunc_neon') and not v.debuff then
            v:calculate_joker({debuffed_card = scoring_hand[i]})
        end
    end
end

'''

# function CardArea:parse_highlighted (Registration Plate 1/3)
[[patches]]
[patches.pattern]
target = 'cardarea.lua'
pattern = "update_hand_text({immediate = true, nopulse = nil, delay = 0}, {handname=disp_text, level=G.GAME.hands[text].level, mult = G.GAME.hands[text].mult, chips = G.GAME.hands[text].chips})"
position = 'at'
match_indent = true
payload = '''
if text == 'bunc_Deal' then
    update_hand_text({immediate = true, nopulse = nil, delay = 0}, {handname=disp_text, level='0', mult = G.GAME.hands[text].mult, chips = G.GAME.hands[text].chips})
else
    update_hand_text({immediate = true, nopulse = nil, delay = 0}, {handname=disp_text, level=G.GAME.hands[text].level, mult = G.GAME.hands[text].mult, chips = G.GAME.hands[text].chips})
end
'''

# function Game:set_globals (Registration Plate 2/3)
[[patches]]
[patches.pattern]
target = 'globals.lua'
pattern = "G.C.HAND_LEVELS[0] = G.C.RED"
position = 'at'
match_indent = true
payload = '''
G.C.HAND_LEVELS[0] = G.C.JOKER_GREY
'''

# function level_up_hand (Registration Plate 3/3)
[[patches]]
[patches.pattern]
target = 'functions/common_events.lua'
pattern = "function level_up_hand(card, hand, instant, amount)"
position = 'after'
match_indent = true
payload = '''
if hand == 'bunc_Deal' then return end
'''

# function level_up_hand (Head in the Clouds)
[[patches]]
[patches.pattern]
target = 'functions/common_events.lua'
pattern = "function level_up_hand(card, hand, instant, amount)"
position = 'after'
match_indent = true
payload = '''

if G.jokers ~= nil then
    for _, v in ipairs(G.jokers.cards) do
        if v.config.center.key == 'j_bunc_head_in_the_clouds' and not v.debuff then
            if (amount == nil) or not (amount <= 0) then
                v:calculate_joker({level_up_hand = hand})
            end
        end
    end
end

if hand == 'Head in the Clouds' then hand = 'High Card' end

'''

# function Card:highlight (Trigger Finger)
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = 'self.highlighted = is_higlighted'
position = 'after'
match_indent = true
payload = '''

if G.jokers ~= nil then
    for _, v in ipairs(G.jokers.cards) do
        if v.config.center.key == 'j_bunc_trigger_finger' and not v.debuff and is_higlighted and self.area == G.hand then
            if pseudorandom('trigger_finger'..G.SEED) < G.GAME.probabilities.normal / v.ability.extra.odds then
                v:calculate_joker({highlight_card = true})
                break
            end
        end
    end
end

'''

# function Card:draw (Vandalism 1/7)
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = '''self.children.center.states.hover = self.states.hover'''
position = 'before'
match_indent = true
payload = '''

if _center.name == 'Vandalism' and (_center.discovered or self.bypass_discovery_center) then
    self.children.center = Sprite(self.T.x, self.T.y, self.T.w, self.T.h, G.ASSET_ATLAS[(G.GAME.viewed_back or G.GAME.selected_back) and ((G.GAME.viewed_back or G.GAME.selected_back)[G.SETTINGS.colourblind_option and 'hc_atlas' or 'lc_atlas'] or (G.GAME.viewed_back or G.GAME.selected_back).atlas) or 'centers'], self.params.bypass_back or (self.playing_card and G.GAME[self.back].pos or G.P_CENTERS['b_red'].pos))
end

'''

# function Card:draw (Vandalism 2/7 - Vanilla)
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = '''if (self.edition and self.edition.negative) or (self.ability.name == 'Antimatter' and (self.config.center.discovered or self.bypass_discovery_center)) then'''
position = 'before'
match_indent = true
payload = '''

if self.config.center.key == 'j_bunc_vandalism' and (self.config.center.discovered or self.bypass_discovery_center) then
    self.children.floating_sprite:draw_shader('dissolve', nil, nil, nil, self.children.center, 0, 0)
    if self.edition then
        for k, v in pairs(G.P_CENTER_POOLS.Edition) do
            if self.edition[v.key:sub(3)] and v.shader then
                self.children.floating_sprite:draw_shader(v.shader, nil, self.ARGS.send_to_shader, nil, self.children.center, 0, 0)
            end
        end
    end
end

'''

# function Card:draw (Vandalism 2/7 - Cryptid Compat)
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = '''if (self.edition and (self.edition.negative or self.edition.cry_oversat)) or (self.ability.name == 'Antimatter' and (self.config.center.discovered or self.bypass_discovery_center)) then'''
position = 'before'
match_indent = true
payload = '''

if self.config.center.key == 'j_bunc_vandalism' and (self.config.center.discovered or self.bypass_discovery_center) then
    self.children.floating_sprite:draw_shader('dissolve', nil, nil, nil, self.children.center, 0, 0)
    if self.edition then
        for k, v in pairs(G.P_CENTER_POOLS.Edition) do
            if self.edition[v.key:sub(3)] and v.shader then
                self.children.floating_sprite:draw_shader(v.shader, nil, self.ARGS.send_to_shader, nil, self.children.center, 0, 0)
            end
        end
    end
end

'''

# function Card:draw (Vandalism 3/7)
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = '''self.children.center:draw_shader('negative_shine', nil, self.ARGS.send_to_shader)'''
position = 'after'
match_indent = true
payload = '''

if self.config.center.key == 'j_bunc_vandalism' and (self.config.center.discovered or self.bypass_discovery_center) then
    self.children.floating_sprite:draw_shader('dissolve', nil, nil, nil, self.children.center, 0, 0)
    if self.edition then
        for k, v in pairs(G.P_CENTER_POOLS.Edition) do
            if self.edition[v.key:sub(3)] and v.shader then
                self.children.floating_sprite:draw_shader(v.shader, nil, self.ARGS.send_to_shader, nil, self.children.center, 0, 0)
            end
        end
    end
end

'''

# function Card:draw (Vandalism 4/7)
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = '''self.children.floating_sprite:draw_shader('dissolve', nil, nil, nil, self.children.center, scale_mod, rotate_mod)'''
position = 'at'
match_indent = true
payload = '''

if self.ability.name ~= 'Vandalism' then
    self.children.floating_sprite:draw_shader('dissolve', nil, nil, nil, self.children.center, scale_mod, rotate_mod)
end

'''

# function Card:draw (Vandalism 5/7)
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = '''self.children.floating_sprite:draw_shader('dissolve',0, nil, nil, self.children.center,scale_mod, rotate_mod,nil, 0.1 + 0.03*math.sin(1.8*G.TIMERS.REAL),nil, 0.6)'''
position = 'at'
match_indent = true
payload = '''

if self.ability.name ~= 'Vandalism' then
    self.children.floating_sprite:draw_shader('dissolve',0, nil, nil, self.children.center,scale_mod, rotate_mod,nil, 0.1 + 0.03*math.sin(1.8*G.TIMERS.REAL),nil, 0.6)
end

'''

# function Blind:stay_flipped (Vandalism 6/7)
[[patches]]
[patches.pattern]
target = 'blind.lua'
pattern = '''if self.name == 'The Wheel' and pseudorandom(pseudoseed('wheel')) < G.GAME.probabilities.normal/7 then'''
position = 'before'
match_indent = true
payload = '''

if G.jokers ~= nil then
    for _, v in ipairs(G.jokers.cards) do
        if v.config.center.key == 'j_bunc_vandalism' and not v.debuff then
            if (pseudorandom('vandalism'..G.SEED) < G.GAME.probabilities.normal / v.ability.extra.odds) and (G.STATE == G.STATES.SELECTING_HAND or G.STATE == G.STATES.DRAW_TO_HAND) then
                v:calculate_joker({stay_flipped = true})
                return true
            end
        end
    end
end

'''

# G.FUNCS.play_cards_from_highlighted (Vandalism 7/7)
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = '''--check the hand first'''
position = 'after'
match_indent = true
payload = '''

if G.jokers ~= nil then
    for _, v in ipairs(G.jokers.cards) do
        if v.config.center.key == 'j_bunc_vandalism' and not v.debuff then
            v:calculate_joker({play_cards = true})
        end
    end
end

'''

# G.FUNCS.reroll_shop (Running Joke)
[[patches]]
[patches.pattern]
target = 'game.lua'
pattern = 'for i = 1, G.GAME.shop.joker_max - #G.shop_jokers.cards do'
position = 'before'
match_indent = true
payload = '''

if G.jokers ~= nil then
    for _, v in ipairs(G.jokers.cards) do
        if v.config.center.key == 'j_bunc_running_joke' and not v.debuff then
            v:calculate_joker({enter_shop = true})
        end
    end
end

'''

# G.FUNCS.draw_from_play_to_discard (Cellphone 1/2)
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = "draw_card(G.play,G.discard, it*100/play_count,'down', false, v)"
position = 'at'
match_indent = true
payload = '''

local cards_to_hand = {}

if G.jokers ~= nil then
    for _, joker in ipairs(G.jokers.cards) do
        if joker.config.center.key == 'j_bunc_cellphone' and joker.ability.extra.active and not joker.debuff then
            for __, card in ipairs(joker.ability.extra.cards_to_hand) do
                table.insert(cards_to_hand, card)
            end
            break
        end
    end
end

if cards_to_hand ~= {} then
    local condition = false
    for _, card_to_hand in ipairs(cards_to_hand) do
        if v == card_to_hand then
            condition = true
        end
    end
    if condition then
        draw_card(G.play,G.hand, it*100/play_count,'up', true, v)
    else
        draw_card(G.play,G.discard, it*100/play_count,'down', false, v)
    end
else
    draw_card(G.play,G.discard, it*100/play_count,'down', false, v)
end

'''

# G.FUNCS.play_cards_from_highlighted() (Cellphone 2/2)
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = "inc_career_stat('c_hands_played', 1)"
position = 'after'
match_indent = true
payload = '''

if G.jokers ~= nil then
    for _, v in ipairs(G.jokers.cards) do
        if v.config.center.key == 'j_bunc_cellphone' and v.ability.extra.active and not v.debuff then
            v:calculate_joker({press_play = true})
            break
        end
    end
end

'''

# G.FUNCS.play_cards_from_highlighted() (Domino 1/5)
[[patches]]
[patches.pattern]
target = 'functions/button_callbacks.lua'
pattern = "if c1 and c1:is(Card) then"
position = 'after'
match_indent = true
payload = '''

local pre_cardarea = c1.area
local pre_card_pos
local pre_card_left
local pre_card_right

if c1.area then
    for i = 1, #c1.area.cards do
        if c1.area.cards[i] == c1 then
            pre_card_pos = i
        end
    end
end

if pre_cardarea and pre_cardarea.cards[pre_card_pos - 1] then pre_card_left = pre_cardarea.cards[pre_card_pos - 1] end
if pre_cardarea and pre_cardarea.cards[pre_card_pos + 1] then pre_card_right = pre_cardarea.cards[pre_card_pos + 1] end

'''

# G.FUNCS.play_cards_from_highlighted() (Domino 2/5)
[[patches]]
[patches.pattern]
target = 'functions/button_callbacks.lua'
pattern = "if G.GAME.modifiers.inflation then"
position = 'before'
match_indent = true
payload = '''

if G.jokers ~= nil then
    for _, v in ipairs(G.jokers.cards) do
        if v.config.center.key == 'j_bunc_domino' and not v.debuff then
            v:calculate_joker({buying_card = true,
            card = c1,
            pre_cardarea = pre_cardarea,
            pre_card_pos = pre_card_pos,
            pre_card_left = pre_card_left,
            pre_card_right = pre_card_right})
            break
        end
    end
end

'''

# G.FUNCS.play_cards_from_highlighted() (Domino 3/5)
[[patches]]
[patches.pattern]
target = 'functions/button_callbacks.lua'
pattern = "if card:check_use() then"
position = 'before'
match_indent = true
payload = '''

local pre_cardarea = card.area
local pre_card_pos
local pre_card_left
local pre_card_right

if card.area then
    for i = 1, #card.area.cards do
        if card.area.cards[i] == card then
            pre_card_pos = i
        end
    end
end

if pre_cardarea and pre_cardarea.cards[pre_card_pos - 1] then pre_card_left = pre_cardarea.cards[pre_card_pos - 1] end
if pre_cardarea and pre_cardarea.cards[pre_card_pos + 1] then pre_card_right = pre_cardarea.cards[pre_card_pos + 1] end

local function call_getting_booster_card()
    G.E_MANAGER:add_event(Event{func = function()
        if G.jokers ~= nil then
            for _, v in ipairs(G.jokers.cards) do
                if v.config.center.key == 'j_bunc_domino' and not v.debuff then
                    v:calculate_joker({getting_booster_card = true,
                    card = card,
                    pre_cardarea = pre_cardarea,
                    pre_card_pos = pre_card_pos,
                    pre_card_left = pre_card_left,
                    pre_card_right = pre_card_right})
                    break
                end
            end
        end
        return true
    end})
end

'''

# G.FUNCS.play_cards_from_highlighted() (Domino 4/5)
[[patches]]
[patches.pattern]
target = 'functions/button_callbacks.lua'
pattern = "card:add_to_deck()"
position = 'after'
match_indent = true
payload = '''

call_getting_booster_card()

'''

# G.FUNCS.play_cards_from_highlighted() (Domino 5/5)
[[patches]]
[patches.pattern]
target = 'functions/button_callbacks.lua'
pattern = "e.config.ref_table:use_consumeable(area)"
position = 'before'
match_indent = true
payload = '''

call_getting_booster_card()

'''

# function Card:is_suit (Myopia & Astigmatism)
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = "if next(find_joker('Smeared Joker')) and (self.base.suit == 'Hearts' or self.base.suit == 'Diamonds') == (suit == 'Hearts' or suit == 'Diamonds') then"
position = 'before'
match_indent = true
payload = '''

if G.jokers ~= nil then
    for _, v in ipairs(G.jokers.cards) do
        if v.config.center.key == 'j_bunc_myopia' and not v.debuff then
            if self.base.suit == 'Spades' and (self.base.suit == 'Spades') == (suit == 'Spades' or suit == 'bunc_Halberds') then
                return true
            end
            if self.base.suit == 'Clubs' and (self.base.suit == 'Clubs') == (suit == 'Clubs' or suit == 'bunc_Halberds') then
                return true
            end
        end
    end
end

if G.jokers ~= nil then
    for _, v in ipairs(G.jokers.cards) do
        if v.config.center.key == 'j_bunc_astigmatism' and not v.debuff then
            if self.base.suit == 'Hearts' and (self.base.suit == 'Hearts') == (suit == 'Hearts' or suit == 'bunc_Fleurons') then
                return true
            end
            if self.base.suit == 'Diamonds' and (self.base.suit == 'Diamonds') == (suit == 'Diamonds' or suit == 'bunc_Fleurons') then
                return true
            end
        end
    end
end

if G.jokers ~= nil then
    for _, v in ipairs(G.jokers.cards) do
        if v.ability.name == 'Smeared Joker' and not v.debuff then
            if self.base.suit == 'bunc_Fleurons' and (suit ~= 'bunc_Fleurons') then
                return false
            end
            if self.base.suit == 'bunc_Halberds' and (suit ~= 'bunc_Halberds') then
                return false
            end
            if (self.base.suit ~= 'bunc_Fleurons' and self.base.suit ~= 'bunc_Halberds') and (suit == 'bunc_Fleurons' or suit == 'bunc_Halberds') then
                return false
            end
        end
    end
end

'''

# Challenge cards unlocking 1/2
[[patches]]
[patches.pattern]
target = 'functions/common_events.lua'
pattern = "unlock_achievement('rule_bender')"
position = 'before'
match_indent = true
payload = '''

local challenge_card

for i = 1, #G.P_LOCKED do
    challenge_card = G.P_LOCKED[i]

    if not challenge_card.unlocked and challenge_card.check_for_unlock and type(challenge_card.check_for_unlock) == 'function' then
        challenge_card:check_for_unlock({type = 'win_challenge'})
    end
end

'''

# Challenge cards unlocking 2/2
[[patches]]
[patches.pattern]
target = 'functions/common_events.lua'
pattern = "if G.GAME.seeded or G.GAME.challenge then return end"
position = 'at'
match_indent = true
payload = '''if G.GAME.seeded or (G.GAME.challenge and not card.challenge_bypass) then return end'''

# Repetition unlocking
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = 'for j=1,#reps do'
position = 'before'
match_indent = true
payload = '''

local locked_card

for i = 1, #G.P_LOCKED do
    locked_card = G.P_LOCKED[i]

    if not locked_card.unlocked and locked_card.check_for_unlock and type(locked_card.check_for_unlock) == 'function' then
        locked_card:check_for_unlock({type = 'repetition', repetition_amount = #reps})
    end
end

'''

# Deck size unlocking (1/2)
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = 'G.GAME.current_round.discards_left = math.max(0, G.GAME.round_resets.discards + G.GAME.round_bonus.discards)'
position = 'before'
match_indent = true
payload = '''

local deck_size = 0

G.GAME.last_deck_size = G.GAME.last_deck_size

for k, v in pairs(G.playing_cards) do
    deck_size = deck_size + 1
end

if G.GAME.last_deck_size ~= deck_size then
    local locked_card
    local difference = deck_size - G.GAME.last_deck_size

    for i = 1, #G.P_LOCKED do
        locked_card = G.P_LOCKED[i]

        if not locked_card.unlocked and locked_card.check_for_unlock and type(locked_card.check_for_unlock) == 'function' then
            locked_card:check_for_unlock({type = 'round_deck_size', round_deck_size_diff = difference})
        end
    end
end

G.GAME.last_deck_size = deck_size

'''

# Deck size unlocking (2/2)
[[patches]]
[patches.pattern]
target = 'game.lua'
pattern = 'self.HUD:recalculate()'
position = 'after'
match_indent = true
payload = '''

local deck_size = 0

for k, v in pairs(G.playing_cards) do
    deck_size = deck_size + 1
end

G.GAME.last_deck_size = deck_size

'''

# Money spending unlocking (1/2)
[[patches]]
[patches.pattern]
target = 'functions/common_events.lua'
pattern = 'function ease_dollars(mod, instant)'
position = 'after'
match_indent = true
payload = '''

G.GAME.money_spend_this_round = G.GAME.money_spend_this_round or 0

if mod < 0 then
    G.GAME.money_spend_this_round = G.GAME.money_spend_this_round - mod

    local locked_card

    for i = 1, #G.P_LOCKED do
        locked_card = G.P_LOCKED[i]

        if not locked_card.unlocked and locked_card.check_for_unlock and type(locked_card.check_for_unlock) == 'function' then
            locked_card:check_for_unlock({type = 'round_spend_money', round_spend_money = G.GAME.money_spend_this_round})
        end
    end
end

'''

# Money spending unlocking (2/2)
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = 'G.GAME.current_round.discards_left = math.max(0, G.GAME.round_resets.discards + G.GAME.round_bonus.discards)'
position = 'before'
match_indent = true
payload = '''G.GAME.money_spend_this_round = 0'''

# Blind defeat unlocking
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = '''function end_round()'''
position = 'after'
match_indent = true
payload = '''

if not G.GAME.blind.disabled then
    local locked_card

    for i = 1, #G.P_LOCKED do
        locked_card = G.P_LOCKED[i]

        if not locked_card.unlocked and locked_card.check_for_unlock and type(locked_card.check_for_unlock) == 'function' then
            locked_card:check_for_unlock({type = 'defeat_blind', blind = G.GAME.blind})
        end
    end
end

'''

# Booster pack unlocking - Per profile
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = '''if self.ability.set == "Booster" then'''
position = 'after'
match_indent = true
payload = '''

G.PROFILES[G.SETTINGS.profile].booster_packs_opened = (G.PROFILES[G.SETTINGS.profile].booster_packs_opened or 0) + 1
if G.PROFILES[G.SETTINGS.profile].booster_packs_opened then
    local locked_card

    for i = 1, #G.P_LOCKED do
        locked_card = G.P_LOCKED[i]

        if not locked_card.unlocked and locked_card.check_for_unlock and type(locked_card.check_for_unlock) == 'function' then
            locked_card:check_for_unlock({type = 'open_pack', packs_total = G.PROFILES[G.SETTINGS.profile].booster_packs_opened})
        end
    end
end

'''

# Booster pack unlocking - Per game (1/2)
[[patches]]
[patches.pattern]
target = 'game.lua'
pattern = 'hands_played = 0,'
position = 'after'
match_indent = true
payload = '''booster_packs_opened = 0,'''

# Booster pack unlocking - Per game (2/2)
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = '''if self.ability.set == "Booster" then'''
position = 'after'
match_indent = true
payload = '''

G.GAME.booster_packs_opened = G.GAME.booster_packs_opened + 1

'''

# Ante down unlocking
[[patches]]
[patches.pattern]
target = 'functions/common_events.lua'
pattern = 'G.GAME.round_resets.ante = G.GAME.round_resets.ante + mod'
position = 'after'
match_indent = true
payload = '''

if mod < 0 then
    G.GAME.money_spend_this_round = G.GAME.money_spend_this_round - mod

    local locked_card

    for i = 1, #G.P_LOCKED do
        locked_card = G.P_LOCKED[i]

        if not locked_card.unlocked and locked_card.check_for_unlock and type(locked_card.check_for_unlock) == 'function' then
            locked_card:check_for_unlock({type = 'ante_down', ante = G.GAME.round_resets.ante})
        end
    end
end

'''

# Common Joker count unlocking (1/2)
[[patches]]
[patches.pattern]
target = 'game.lua'
pattern = 'max_jokers = 0,'
position = 'after'
match_indent = true
payload = '''max_common_jokers = 0,'''

# Common Joker count unlocking (2/2)
[[patches]]
[patches.pattern]
target = 'cardarea.lua'
pattern = 'if joker_tally > G.GAME.max_jokers then G.GAME.max_jokers = joker_tally end'
position = 'after'
match_indent = true
payload = '''

local common_joker_tally = 0
for i = 1, #G.jokers.cards do
    if G.jokers.cards[i].ability.set == 'Joker' and G.jokers.cards[i].config.center.rarity == 1 then common_joker_tally = common_joker_tally + 1 end
end
if common_joker_tally > G.GAME.max_common_jokers then G.GAME.max_common_jokers = common_joker_tally end

'''

# Consumables with edition unlocking
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = 'local used_tarot = copier or self'
position = 'after'
match_indent = true
payload = '''

if used_tarot.edition then
    G.PROFILES[G.SETTINGS.profile].consumables_with_edition_used = (G.PROFILES[G.SETTINGS.profile].consumables_with_edition_used or 0) + 1
    if G.PROFILES[G.SETTINGS.profile].consumables_with_edition_used then
        local locked_card

        for i = 1, #G.P_LOCKED do
            locked_card = G.P_LOCKED[i]

            if not locked_card.unlocked and locked_card.check_for_unlock and type(locked_card.check_for_unlock) == 'function' then
                locked_card:check_for_unlock({type = 'use_consumable_with_edition', used_total = G.PROFILES[G.SETTINGS.profile].consumables_with_edition_used})
            end
        end
    end
end

'''

# Flipped cards in hand unlocking
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = '''--check the hand first'''
position = 'after'
match_indent = true
payload = '''

local unlock_all_flipped = true

for i = 1, #G.hand.highlighted do
    if G.hand.highlighted[i].facing ~= 'back' then
        unlock_all_flipped = false
    end
end

if (not G.hand.highlighted) or (#G.hand.highlighted == 0) then unlock_all_flipped = false end

if unlock_all_flipped and #G.hand.highlighted >= 5 then
    local locked_card

    for i = 1, #G.P_LOCKED do
        locked_card = G.P_LOCKED[i]

        if not locked_card.unlocked and locked_card.check_for_unlock and type(locked_card.check_for_unlock) == 'function' then
            locked_card:check_for_unlock({type = 'play_all_flipped'})
        end
    end
end

'''

# Enhancement usage detection unlocking (1/2)
[[patches]]
[patches.pattern]
target = 'game.lua'
pattern = 'bosses_used = bosses_used,'
position = 'after'
match_indent = true
payload = '''enhancements_used = false,'''

# Enhancement usage detection unlocking (2/2)
[[patches]]
[patches.pattern]
target = 'functions/common_events.lua'
pattern = '''if args.type == 'modify_deck' then'''
position = 'after'
match_indent = true
payload = '''

local enhancement_count = 0
for _, v in pairs(G.playing_cards) do
    if v.config.center ~= G.P_CENTERS.c_base then G.GAME.enhancements_used = true break end
end

'''

# Total skips unlocking
[[patches]]
[patches.pattern]
target = 'functions/button_callbacks.lua'
pattern = 'G.GAME.skips = (G.GAME.skips or 0) + 1'
position = 'after'
match_indent = true
payload = '''

G.PROFILES[G.SETTINGS.profile].skips_total = (G.PROFILES[G.SETTINGS.profile].skips_total or 0) + 1
if G.PROFILES[G.SETTINGS.profile].skips_total then
    local locked_card

    for i = 1, #G.P_LOCKED do
        locked_card = G.P_LOCKED[i]

        if not locked_card.unlocked and locked_card.check_for_unlock and type(locked_card.check_for_unlock) == 'function' then
            locked_card:check_for_unlock({type = 'blind_skipped', skips_total = G.PROFILES[G.SETTINGS.profile].skips_total})
        end
    end
end

'''

# G.FUNCS.discard_cards_from_highlighted() (The Paling 1/2)
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = 'G.GAME.current_round.discards_used = G.GAME.current_round.discards_used + 1'
position = 'after'
match_indent = true
payload = '''

if G.GAME.blind and G.GAME.blind.name == 'bl_bunc_paling' and not G.GAME.blind.disabled and not hook then
    if G.GAME.current_round.hands_left > 1 then
        ease_hands_played(-1) --
    elseif G.GAME.current_round.hands_left == 1 or G.GAME.current_round.hands_left == 0 then
        ease_hands_played(-1) --

        G.E_MANAGER:add_event(Event({ trigger = 'after', delay = 1.8, func = function()
            G.STATE = G.STATES.GAME_OVER
            if not G.GAME.won and not G.GAME.seeded and not G.GAME.challenge then 
                G.PROFILES[G.SETTINGS.profile].high_scores.current_streak.amt = 0
            end
            G:save_settings()
            G.FILE_HANDLER.force = true
            G.STATE_COMPLETE = false
        return true end }))
    end
    G.GAME.blind:wiggle()
end

'''

# G.FUNCS.play_cards_from_highlighted() (The Paling 2/2)
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = "inc_career_stat('c_hands_played', 1)"
position = 'after'
match_indent = true
payload = '''

if G.GAME.blind and G.GAME.blind.name == 'bl_bunc_paling' and not G.GAME.blind.disabled then
    if G.GAME.current_round.discards_left >= 1 then
        ease_discard(-1, true)
        G.GAME.blind:wiggle()
        G.GAME.blind.triggered = true
    end
end

'''

# G.FUNCS.play_cards_from_highlighted() (The Umbrella)
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = "inc_career_stat('c_hands_played', 1)"
position = 'after'
match_indent = true
payload = '''

if G.GAME.blind and G.GAME.blind.name == 'bl_bunc_umbrella' and not G.GAME.blind.disabled then
    G.E_MANAGER:add_event(Event({func = function()

        for k, v in ipairs(G.hand.cards) do
            if v.facing == 'front' and not v.highlighted then
                v:flip()
            end
        end

        G.GAME.blind:wiggle()
        G.GAME.blind.triggered = true

    return true end }))
end

'''

# The Tine 1/3
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = "highlight_card(scoring_hand[i],(i-0.999)/5,'up')"
position = 'after'
match_indent = true
payload = '''

local played_rank = scoring_hand[i].base.value

if G.GAME.played_ranks == nil then G.GAME.played_ranks = {} end

if G.GAME.played_ranks[played_rank] then
    G.GAME.played_ranks[played_rank] = G.GAME.played_ranks[played_rank] + 1
else
    G.GAME.played_ranks[played_rank] = 1
end

'''

# function end_round() (The Tine 2/3)
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = "G.GAME.current_round.most_played_poker_hand = _handname"
position = 'before'
match_indent = true
payload = '''

if G.GAME.played_ranks ~= nil then
    local max_rank = nil
    local max_count = -1

    for _, rank in ipairs(SMODS.Rank.obj_buffer) do
        count = G.GAME.played_ranks[rank] or 0
        -- tiebreak with highest rank
        if count >= max_count then
            max_count = count
            max_rank = rank
        end
    end

    G.GAME.current_round.most_played_rank = max_rank
end


'''

# The Tine 3/3
[[patches]]
[patches.pattern]
target = 'game.lua'
pattern = "most_played_poker_hand = 'High Card',"
position = 'after'
match_indent = true
payload = '''
most_played_rank = '2','''

# G.FUNCS.discard_cards_from_highlighted() (The Swing 1/2)
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = 'G.GAME.current_round.discards_used = G.GAME.current_round.discards_used + 1'
position = 'after'
match_indent = true
payload = '''

if G.GAME.blind and G.GAME.blind.name == 'bl_bunc_swing' and not G.GAME.blind.disabled then
    G.E_MANAGER:add_event(Event({ func = function()
        for k, v in ipairs(G.hand.cards) do
            v:flip()
        end

        G.GAME.blind:wiggle()
        G.GAME.blind.triggered = true

        if G.GAME.Swing == true then
            G.GAME.Swing = false
        else
            G.GAME.Swing = true
        end
    return true end }))
end

'''

# G.FUNCS.play_cards_from_highlighted() (The Swing 2/2)
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = "inc_career_stat('c_hands_played', 1)"
position = 'after'
match_indent = true
payload = '''

if G.GAME.blind and G.GAME.blind.name == 'bl_bunc_swing' and not G.GAME.blind.disabled then
    G.E_MANAGER:add_event(Event({ func = function()
        for k, v in ipairs(G.hand.cards) do
            if not (v.area == G.hand and v.highlighted and v.facing == 'front') then
                v:flip()
            end
        end

        G.GAME.blind:wiggle()
        G.GAME.blind.triggered = true

        if G.GAME.Swing == true then
            G.GAME.Swing = false
        else
            G.GAME.Swing = true
        end
    return true end }))
end

'''

# G.FUNCS.cash_out (The Miser)
[[patches]]
[patches.pattern]
target = 'functions/button_callbacks.lua'
pattern = 'G.STATE = G.STATES.SHOP'
position = 'at'
match_indent = true
payload = '''

if G.GAME.Miser then
    G.STATE = G.STATES.BLIND_SELECT
    G.GAME.Miser = false
else
    G.STATE = G.STATES.SHOP
end

'''

# function Card:highlight (The Gate 1/2)
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = 'self.highlighted = is_higlighted'
position = 'after'
match_indent = true
payload = '''

if G.GAME.blind and G.GAME.blind.name == 'bl_bunc_gate' and not G.GAME.blind.disabled and is_higlighted and self.area == G.hand then
    self.ability.forced_selection = true
end

'''

# function CardArea:remove_from_highlighted (The Gate 2/2)
[[patches]]
[patches.pattern]
target = 'cardarea.lua'
pattern = 'function CardArea:remove_from_highlighted(card, force)'
position = 'after'
match_indent = true
payload = '''

if G.GAME.blind and G.GAME.blind.name == 'bl_bunc_gate' and not force and card.area == G.hand then
    if G.GAME.blind.disabled then
        card.ability.forced_selection = false
    elseif not G.GAME.blind.disabled and card.ability.forced_selection == true then
        G.GAME.blind:wiggle()
    end
end

'''

# function end_round() (The Mask 1/2)
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = "G.GAME.current_round.most_played_poker_hand = _handname"
position = 'before'
match_indent = true
payload = '''

local lowestValue = math.huge
local leastPlayedHand = ''

for i = #G.handlist, 1, -1 do
    local v = G.handlist[i]
    local playedCount = G.GAME.hands and G.GAME.hands[v] and G.GAME.hands[v].played or 0
    if (playedCount < lowestValue) and G.GAME.hands[v].visible then
        lowestValue = G.GAME.hands[v].visible and playedCount or lowestValue
        leastPlayedHand = G.GAME.hands[v].visible and v or leastPlayedHand
    end
end

G.GAME.current_round.least_played_poker_hand = leastPlayedHand

'''

# The Mask 2/2
[[patches]]
[patches.pattern]
target = 'game.lua'
pattern = "most_played_poker_hand = 'High Card',"
position = 'after'
match_indent = true
payload = '''
least_played_poker_hand = 'High Card','''

# The Blade
[[patches]]
[patches.regex]
target = 'functions/state_events.lua'
pattern = "(?<indent>[\t ]*)else\\s*\\n[\\t ]*mult\\s*=\\s*mod_mult\\(\\s*0\\s*\\)\\s*\\n[\\t ]*hand_chips\\s*=\\s*mod_chips\\(\\s*0\\s*\\)\\s*"
position = 'before'
line_prepend = '$indent'
payload = '''

if G.GAME.blind and G.GAME.blind.name == 'bl_bunc_blade' and not G.GAME.blind.disabled then

    local overscore = G.GAME.blind.chips * 1.5

    if type(hand_chips) == 'table' then overscore = to_big(overscore) end

    if (overscore < math.floor(hand_chips*mult) + G.GAME.chips) then

        mult = mod_mult(0)
        hand_chips = mod_chips(0)

        G.E_MANAGER:add_event(Event({
            trigger = 'after',
            func = (function()
                G.GAME.blind:disable()
                return true
            end)
        }))

        local blade_message = BUNCOMOD and BUNCOMOD.loc.exceeded_score or ' '
        play_area_status_text(blade_message)

    end
end

'''

# G.FUNCS.discard_cards_from_highlighted (The Claw)
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = "draw_card(G.hand, G.discard, i*100/highlighted_count, 'down', false, G.hand.highlighted[i])"
position = 'at'
match_indent = true
payload = '''

if G.GAME.blind and G.GAME.blind.name == 'bl_bunc_claw' and not G.GAME.blind.disabled then
    draw_card(G.hand, G.deck, i*100/highlighted_count, 'down', false, G.hand.highlighted[i])
    G.deck:shuffle('claw'..G.GAME.round_resets.ante)
else
    draw_card(G.hand, G.discard, i*100/highlighted_count, 'down', false, G.hand.highlighted[i])
end

'''

# function Card:highlight (The Veil)
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = 'self.highlighted = is_higlighted'
position = 'after'
match_indent = true
payload = '''

if G.GAME.blind and G.GAME.blind.name == 'bl_bunc_veil' and not G.GAME.blind.disabled and is_higlighted and self.area == G.hand then
    if self.facing == 'front' then
        self:flip()
        G.GAME.blind:wiggle()
    end
end

'''

# G.FUNCS.cash_out (Vermilion Trident 1/2)
[[patches]]
[patches.pattern]
target = 'functions/button_callbacks.lua'
pattern = 'G.STATE = G.STATES.SHOP'
position = 'at'
match_indent = true
payload = '''

if G.GAME.Trident and not next(find_joker('Chicot')) then
    G.STATE = G.STATES.BLIND_SELECT
else
    G.STATE = G.STATES.SHOP
end

'''

# function get_new_boss() (Vermilion Trident 2/2)
[[patches]]
[patches.pattern]
target = 'game.lua'
pattern = 'function Game:update(dt)'
position = 'after'
match_indent = true
payload = '''

if G.GAME.round_resets.blind_choices and G.GAME.round_resets.blind_choices.Boss and G.GAME.round_resets.blind_choices.Boss == 'bl_bunc_final_trident' then
    G.GAME.Trident = true
else
    G.GAME.Trident = false
end

'''

# G.FUNCS.discard_cards_from_highlighted (Magenta Dagger 1/5)
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = "G.FUNCS.discard_cards_from_highlighted = function(e, hook)"
position = 'after'
match_indent = true
payload = '''

if G.GAME.blind and G.GAME.blind.name == 'bl_bunc_final_dagger' and not G.GAME.blind.disabled then
    G.GAME.blind:wiggle()
    G.GAME.blind.antiscore = true
    G.FUNCS.play_cards_from_highlighted()
    return
end

'''

# G.FUNCS.play_cards_from_highlighted (Magenta Dagger 2/5)
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = "ease_hands_played(-1)"
position = 'at'
match_indent = true
payload = '''

local function calculate_discard()
    for i = 1, #G.hand.cards do
        eval_card(G.hand.cards[i], {pre_discard = true, full_hand = G.hand.highlighted, hook = hook})
    end
    for j = 1, #G.jokers.cards do
        G.jokers.cards[j]:calculate_joker({pre_discard = true, full_hand = G.hand.highlighted, hook = hook})
    end
end

if G.GAME.blind.antiscore then
    ease_discard(-1)
    calculate_discard()
else
    ease_hands_played(-1)
end

'''

# G.FUNCS.play_cards_from_highlighted (Magenta Dagger 3/5)
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = "G.FUNCS.evaluate_play()"
position = 'after'
match_indent = true
payload = '''

if G.GAME.blind.antiscore then
    G.GAME.blind.antiscore = false
end

'''

# G.FUNCS.play_cards_from_highlighted (Magenta Dagger 4/5)
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = "G.FUNCS.evaluate_play = function(e)"
position = 'after'
match_indent = true
payload = '''

local antiscore = G.GAME.blind.antiscore

'''

# function update_hand_text (Magenta Dagger 5/5)
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = "ease_to = G.GAME.chips + math.floor(hand_chips*mult),"
position = 'at'
match_indent = true
payload = '''ease_to = G.GAME.chips + math.floor(hand_chips * mult) * (antiscore and -1 or 1),'''

# function get_new_boss() (Turquoise Shield 1/2)
[[patches]]
[patches.pattern]
target = 'game.lua'
pattern = 'function Game:update(dt)'
position = 'after'
match_indent = true
payload = '''

if G.GAME.round_resets.blind_choices and G.GAME.round_resets.blind_choices.Boss and G.GAME.round_resets.blind_choices.Boss == 'bl_bunc_final_shield' then
    G.GAME.Shield = true
else
    G.GAME.Shield = false
end

'''

# function end_round() (Turquoise Shield 2/2)
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = "function end_round()"
position = 'after'
match_indent = true
payload = '''
if G.GAME.Shield == true then
    if type(G.GAME.chips) ~= 'table' then
        if G.GAME.chips - G.GAME.blind.chips >= 0 then
            G.GAME.overscore = (G.GAME.overscore or 0) + G.GAME.chips - G.GAME.blind.chips
        end
    else
        if G.GAME.chips - G.GAME.blind.chips >= to_big(0) then
            G.GAME.overscore = (G.GAME.overscore or 0) + G.GAME.chips - G.GAME.blind.chips
        end
    end
end
'''

# Insta-yep for tags, delayless yep
[[patches]]
[patches.pattern]
target = 'tag.lua'
pattern = 'function Tag:yep(message, _colour, func)'
position = 'before'
match_indent = true
payload = '''

function Tag:instayep(message, _colour, func, delay)
    stop_use()
    if delay then
        G.E_MANAGER:add_event(Event({
        delay = delay,
        trigger = 'after',
        func = (function()
            attention_text({
                text = message,
                colour = G.C.WHITE,
                scale = 1, 
                hold = 0.3/G.SETTINGS.GAMESPEED,
                cover = self.HUD_tag,
                cover_colour = _colour or G.C.GREEN,
                align = 'cm',
                })
            play_sound('generic1', 0.9 + math.random()*0.1, 0.8)
            play_sound('holo1', 1.2 + math.random()*0.1, 0.4)
            return true
        end)
        }))
        G.E_MANAGER:add_event(Event({
            func = (function()
                self.HUD_tag.states.visible = false
                return true
            end)
        }))
        G.E_MANAGER:add_event(Event({
            func = func
        }))
        G.E_MANAGER:add_event(Event({
            trigger = 'after',
            delay = 0.7,
            func = (function()
                self:remove()
                return true
            end)
        }))
    else
        attention_text({
            text = message,
            colour = G.C.WHITE,
            scale = 1,
            hold = 0.3/G.SETTINGS.GAMESPEED,
            cover = self.HUD_tag,
            cover_colour = _colour or G.C.GREEN,
            align = 'cm',
            })
        play_sound('generic1', 0.9 + math.random()*0.1, 0.8)
        play_sound('holo1', 1.2 + math.random()*0.1, 0.4)

        G.E_MANAGER:add_event(Event({
            blockable = false,
            blocking = false,
            trigger = 'after',
            func = (function()
                self.HUD_tag.states.visible = false
                return true
            end)
        }))
        G.E_MANAGER:add_event(Event({
            blockable = false,
            blocking = false,
            func = func
        }))
        G.E_MANAGER:add_event(Event({
            blockable = false,
            blocking = false,
            trigger = 'after',
            delay = 0.7,
            func = (function()
                self:remove()
                return true
            end)
        }))
    end
end

'''

# Edition tags 1/5
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = 'local modded = false'
position = 'before'
match_indent = true
payload = '''

for i = 1, #G.GAME.tags do
    G.GAME.tags[i]:apply_to_run({type = 'hand_played', before = true})
end

'''

# Edition tags 2/5
[[patches]]
[patches.regex]
target = 'functions/state_events.lua'
pattern = "(?<indent>[\t ]*)else\\s*\\n[\\t ]*mult\\s*=\\s*mod_mult\\(\\s*0\\s*\\)\\s*\\n[\\t ]*hand_chips\\s*=\\s*mod_chips\\(\\s*0\\s*\\)\\s*"
position = 'before'
line_prepend = '$indent'
payload = '''

for i = 1, #G.GAME.tags do
    G.GAME.tags[i]:apply_to_run({type = 'hand_played', after = true})
end

'''

# function Card:use_consumeable() Edition tags 3/5
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = 'local used_tarot = copier or self'
position = 'after'
match_indent = true
payload = '''

if used_tarot.edition then
    if used_tarot.edition.foil then
        add_tag(Tag('tag_bunc_chips'))
        play_sound('generic1')
    elseif used_tarot.edition.holo then
        add_tag(Tag('tag_bunc_mult'))
        play_sound('generic1')
    elseif used_tarot.edition.polychrome then
        add_tag(Tag('tag_bunc_xmult'))
        play_sound('generic1')
    elseif used_tarot.edition.bunc_glitter then
        add_tag(Tag('tag_bunc_xchips'))
        play_sound('generic1')
    end
end

'''

# Edition tags 4/5
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = 'for i=1, #G.jokers.cards + #G.consumeables.cards do'
position = 'at'
match_indent = true
payload = '''

for i=1, #G.jokers.cards + (BUNCOMOD and BUNCOMOD.vars and BUNCOMOD.vars.jokerlike_consumable_editions and #G.consumeables.cards or 0) do

'''

# Edition tags 5/5
[[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}"
position = 'before'
match_indent = true
payload = '''

for i=1, BUNCOMOD and BUNCOMOD.vars and BUNCOMOD.vars.jokerlike_consumable_editions and 0 or #G.consumeables.cards do
    local _card = G.jokers.cards[i] or G.consumeables.cards[i - #G.jokers.cards]
    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, callback = function(_card, ret) effects = {jokers = ret}

    --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

    end})
end

'''

# Editions in boosters 1/2
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = 'local card = nil'
position = 'after'
match_indent = true
payload = '''

local consumable_edition = {rate = G.GAME.used_vouchers['v_bunc_lamination'] and 2 or 0, forced = G.GAME.used_vouchers['v_bunc_supercoating']}

'''

# Editions in boosters 2/2
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = '''card:start_materialize({G.C.WHITE, G.C.WHITE}, nil, 1.5*G.SETTINGS.GAMESPEED)'''
position = 'before'
match_indent = true
payload = '''

local edition = poll_edition('standard_edition'..G.GAME.round_resets.ante, consumable_edition.rate, true, consumable_edition.forced,
{'e_holo', 'e_foil', 'e_polychrome', 'e_bunc_glitter'})
if not card.edition then
    for _, card_type in ipairs(SMODS.ConsumableType.ctype_buffer) do
        if card.ability.set == card_type then
            card:set_edition(edition)
            break
        end
    end
end

'''

# # Info queue for consumables 1/??? (Doesn't want to work because of lovely not allowing the injections here)
# [[patches]]
# [patches.pattern]
# target = 'functions/common_events.lua'
# pattern = "info_queue[#info_queue + 1] = G.P_CENTERS[v]"
# position = 'at'
# match_indent = true
# payload = '''

# if _c.set ~= 'Joker' then
#     info_queue[#info_queue + 1] = G.P_CENTERS[v]
# end

# '''

# function card_open() (Filigree Tag)
[[patches]]
[patches.regex]
target = 'card.lua'
pattern = "(?<indent>[\t ]*)for\\s+i\\s*=\\s*1,\\s*#G\\.jokers\\.cards\\s*do\\s*\\n[\\t ]*G\\.jokers\\.cards\\[i\\]:calculate_joker\\(\\{\\s*open_booster\\s*=\\s*true,\\s*card\\s*=\\s*self\\s*\\}\\)\\s*\\n[\\t ]*end"
position = 'after'
line_prepend = '$indent'
payload = '''

for i = 1, #G.GAME.tags do
    if (self.ability.name == 'Standard Pack' or
    self.ability.name == 'Jumbo Standard Pack' or
    self.ability.name == 'Mega Standard Pack') then
        if G.GAME.tags[i]:apply_to_run({type = 'standard_pack_opened'}) then break end
    end
end

'''

# Glitter edition 1/2
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = 'if effects[ii].edition then'
position = 'after'
match_indent = true
payload = '''

if scoring_hand and scoring_hand[i] and scoring_hand[i].edition and scoring_hand[i].edition.bunc_glitter then
    local xchips = G.P_CENTERS.e_bunc_glitter.config.Xchips
    hand_chips = mod_chips(hand_chips * xchips)
    update_hand_text({delay = 0}, {chips = hand_chips})
    card_eval_status_text(scoring_hand[i], 'extra', nil, percent, nil,
    {message = 'X'..xchips..' '..BUNCOMOD.loc.chips,
    edition = true,
    x_chips = true})
end

'''

# Two options (bonus first vs bonus last):

# pattern = 'edition_effects.jokers.edition = true'
# position = 'after'

# pattern = 'if edition_effects.jokers.x_mult_mod then'
# position = 'before'

# Glitter edition 2/2
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = 'if edition_effects.jokers.x_mult_mod then'
position = 'before'
match_indent = true
payload = '''

if G.jokers.cards and G.jokers.cards[i] and G.jokers.cards[i].edition and G.jokers.cards[i].edition.bunc_glitter then
    local xchips = G.P_CENTERS.e_bunc_glitter.config.Xchips
    hand_chips = mod_chips(hand_chips * xchips)
    update_hand_text({delay = 0}, {chips = hand_chips})
    card_eval_status_text(G.jokers.cards[i], 'extra', nil, percent, nil,
    {message = 'X'..xchips..' '..BUNCOMOD.loc.chips,
    edition = true,
    x_chips = true})
end

'''

# Fluorescent edition 1/3
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = "if self.facing == 'front' then"
position = 'after'
match_indent = true
payload = '''

if (self.area == G.hand or self.area == G.jokers or self.area == G.consumeables) and self.edition and self.edition.bunc_fluorescent then
    return
end

'''

# Fluorescent edition 2/3
[[patches]]
[patches.pattern]
target = 'cardarea.lua'
pattern = "function CardArea:remove_from_highlighted(card, force)"
position = 'after'
match_indent = true
payload = '''

if card.edition and card.edition.bunc_fluorescent then
    card.ability.forced_selection = false
end

'''

# Fluorescent edition 3/3
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = "function Card:set_debuff(should_debuff)"
position = 'after'
match_indent = true
payload = '''

if self.edition and self.edition.bunc_fluorescent then
    if self.debuff then
        self.debuff = false
        if self.area == G.jokers then self:add_to_deck(true) end
    end
    return
end

'''

# function Blind:press_play() (Hedge Trimmer)
[[patches]]
[patches.pattern]
target = 'blind.lua'
pattern = 'function Blind:press_play()'
position = 'after'
match_indent = true
payload = '''

if G.GAME.used_vouchers['v_bunc_hedge_trimmer'] then
    local final_chips = (G.GAME.blind.chips / 100) * (100 - SMODS.Centers['v_bunc_hedge_trimmer'].config.percent)
    local chip_mod -- iterate over ~120 ticks
    if type(G.GAME.blind.chips) ~= 'table' then
        chip_mod = math.ceil((G.GAME.blind.chips - final_chips) / 120)
    else
        chip_mod = ((G.GAME.blind.chips - final_chips) / 120):ceil()
    end
    local step = 0
    G.E_MANAGER:add_event(Event({trigger = 'after', blocking = true, func = function()
        G.GAME.blind.chips = G.GAME.blind.chips - G.SETTINGS.GAMESPEED * chip_mod
        if G.GAME.blind.chips > final_chips then
            G.GAME.blind.chip_text = number_format(G.GAME.blind.chips)
            if step % 5 == 0 then
                play_sound('chips1', 1.0 - (step * 0.005))
            end
            step = step + 1
        else
            G.GAME.blind.chips = final_chips
            G.GAME.blind.chip_text = number_format(G.GAME.blind.chips)
            return true
        end
    end}))

    G.PROFILES[G.SETTINGS.profile].hedge_trimmer_usage = (G.PROFILES[G.SETTINGS.profile].hedge_trimmer_usage or 0) + 1

    local locked_card

    for i = 1, #G.P_LOCKED do
        locked_card = G.P_LOCKED[i]

        if not locked_card.unlocked and locked_card.check_for_unlock and type(locked_card.check_for_unlock) == 'function' then
            locked_card:check_for_unlock({type = 'hedge_trimmer_used', used_total = G.PROFILES[G.SETTINGS.profile].hedge_trimmer_usage})
        end
    end
end

'''

# Cups 'n' Balls (1/3)
[[patches]]
[patches.pattern]
target = 'game.lua'
pattern = 'joker_max = 2,'
position = 'after'
match_indent = true
payload = '''booster_max = 2,'''

# Cups 'n' Balls (2/3)
[[patches]]
[patches.pattern]
target = 'functions/common_events.lua'
pattern = 'function change_shop_size(mod)'
position = 'before'
match_indent = true
payload = '''

function change_booster_amount(mod)
    if not G.GAME.shop then return end
    G.GAME.shop.booster_max = G.GAME.shop.booster_max + mod
    if G.shop_jokers and G.shop_jokers.cards then
        if mod < 0 then
            --Remove jokers in shop
            for i = #G.shop_booster.cards, G.GAME.shop.booster_max + 1, -1 do
                if G.shop_booster.cards[i] then
                    G.shop_booster.cards[i]:remove()
                end
            end
        end
        G.shop_booster.config.card_limit = G.GAME.shop.booster_max
        G.shop:recalculate()
        if mod > 0 then
            for i = 1, G.GAME.shop.booster_max - #G.shop_booster.cards do
                if G.GAME.current_round.used_packs[i] ~= 'USED' then
                    G.GAME.current_round.used_packs = G.GAME.current_round.used_packs or {}
                    if not G.GAME.current_round.used_packs[i] then
                        G.GAME.current_round.used_packs[i] = get_pack('shop_pack').key
                    end
                    local card = Card(G.shop_booster.T.x + G.shop_booster.T.w/2,
                    G.shop_booster.T.y, G.CARD_W*1.27, G.CARD_H*1.27, G.P_CARDS.empty, G.P_CENTERS[G.GAME.current_round.used_packs[i]], {bypass_discovery_center = true, bypass_discovery_ui = true})
                    create_shop_card_ui(card, 'Booster', G.shop_booster)
                    card:start_materialize()
                    G.shop_booster:emplace(card)
                    card:align()
                end
            end
        end
    end
end

'''

# Cups 'n' Balls (3/3)
[[patches]]
[patches.pattern]
target = 'game.lua'
pattern = 'for i = 1, 2 do'
position = 'at'
match_indent = true
payload = '''for i = 1, G.GAME.shop.booster_max - #G.shop_booster.cards do'''

# Shell Game (1/9)
[[patches]]
[patches.pattern]
target = 'functions/UI_definitions.lua'
pattern = '''{n=G.UIT.R,config={align = "tm",padding = 0.2, minh = 1.2, minw = 1.8, r=0.15,colour = G.C.GREY, one_press = true, button = 'skip_booster', hover = true,shadow = true, func = 'can_skip_booster'}, nodes = {'''
position = 'at'
match_indent = true
payload = '''

(G.GAME.used_vouchers['v_bunc_shell_game'] and not G.GAME.rerolled_pack and
UIBox_button({label = {localize('k_reroll')}, padding = 0.07, minh = 0.7, minw = 1.8, r = 0.15, one_press = true, button = 'reroll_booster_pack', func = 'reroll_booster_pack_button'}) or nil),
G.GAME.used_vouchers['v_bunc_shell_game'] and {n=G.UIT.R,config = {minh = 0.07}, nodes={}},
{n=G.UIT.R, config = {align = G.GAME.used_vouchers['v_bunc_shell_game'] and 'cm' or 'tm', padding = G.GAME.used_vouchers['v_bunc_shell_game'] and 0.07 or 0.2, minh = G.GAME.used_vouchers['v_bunc_shell_game'] and 0.7 or 1.2, minw = 1.8, r = 0.15, colour = G.C.GREY, one_press = true, button = 'skip_booster', hover = true, shadow = true, func = 'can_skip_booster'}, nodes = {

'''

# Shell Game (2/9)
[[patches]]
[patches.pattern]
target = 'functions/button_callbacks.lua'
pattern = 'G.FUNCS.reroll_boss_button = function(e)'
position = 'before'
match_indent = true
payload = '''

G.FUNCS.reroll_booster_pack_button = function(e)
    if (not G.GAME.rerolled_pack) and G.GAME.used_vouchers['v_bunc_shell_game'] and (G.pack_cards and
    G.STATE == G.STATES.SMODS_BOOSTER_OPENED or (G.STATE == G.STATES.PLANET_PACK or G.STATE == G.STATES.STANDARD_PACK or G.STATE == G.STATES.BUFFOON_PACK or (G.hand and (G.hand.cards[1] or (G.hand.config.card_limit <= 0))))) then
        e.config.colour = G.C.GREEN
        e.config.button = 'reroll_booster_pack'
        e.children[1].children[1].config.shadow = true
        if e.children[2] then e.children[2].children[1].config.shadow = true end
    else
        e.config.colour = G.C.UI.BACKGROUND_INACTIVE
        e.config.button = nil
        e.children[1].children[1].config.shadow = false
        if e.children[2] then e.children[2].children[1].config.shadow = false end
    end
end

G.FUNCS.reroll_booster_pack = function(e)
    if G.pack_cards and
    G.STATE == G.STATES.SMODS_BOOSTER_OPENED or (G.STATE == G.STATES.PLANET_PACK or G.STATE == G.STATES.STANDARD_PACK or G.STATE == G.STATES.BUFFOON_PACK or (G.hand and (G.hand.cards[1] or (G.hand.config.card_limit <= 0)))) then
        stop_use()

        local last_pack = G.GAME.last_booster_pack
        last_pack.cost = 0
        last_pack.rerolled = true

        for i = #G.pack_cards.cards, 1, -1 do
            local c = G.pack_cards:remove_card(G.pack_cards.cards[i])
            c:remove()
            c = nil
        end

        G.E_MANAGER:add_event(Event({blocking = false, trigger = 'after', func = function()
            play_sound('other1')
            last_pack:open()
            return true
        end}))
    end
end

'''

# Shell Game (3/9)
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = 'function Card:open()'
position = 'after'
match_indent = true
payload = '''

G.GAME.last_booster_pack = self
G.GAME.rerolled_pack = self.rerolled

'''

# Shell Game (4/9)
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = 'if self.ability.set == "Booster" then'
position = 'after'
match_indent = true
payload = '''if not G.GAME.rerolled_pack then'''

# Shell Game (5/9) (UNSTABLE)
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = 'G.GAME.pack_choices = self.config.center.config.choose or 1'
position = 'after'
match_indent = true
payload = '''end local skip_animation = G.GAME.rerolled_pack and 0 or nil'''

# Shell Game (6/9) (UNSTABLE)
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = '''G.E_MANAGER:add_event(Event({trigger = 'after', delay = 0.4, func = function()'''
position = 'at'
match_indent = true
payload = '''G.E_MANAGER:add_event(Event({trigger = 'after', delay = skip_animation or 0.4, func = function()'''


# Shell Game (7/9)
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = '''self:explode()'''
position = 'at'
match_indent = true
payload = '''if not G.GAME.rerolled_pack then self:explode() end'''

# Shell Game (8/9) (UNSTABLE)
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = '''G.E_MANAGER:add_event(Event({trigger = 'after', delay = 1.3*math.sqrt(G.SETTINGS.GAMESPEED), blockable = false, blocking = false, func = function()'''
position = 'at'
match_indent = true
payload = '''G.E_MANAGER:add_event(Event({trigger = 'after', delay = skip_animation or (1.3*math.sqrt(G.SETTINGS.GAMESPEED)), blockable = false, blocking = false, func = function()'''

# Shell Game (9/9)
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = 'card:start_materialize({G.C.WHITE, G.C.WHITE}, nil, 1.5*G.SETTINGS.GAMESPEED)'
position = 'at'
match_indent = true
payload = '''

if not G.GAME.rerolled_pack then
    card:start_materialize({G.C.WHITE, G.C.WHITE}, nil, 1.5*G.SETTINGS.GAMESPEED)
else
    card:juice_up()
end

'''

# Masquerade
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = 'if self.area and self.ability.couponed and (self.area == G.shop_jokers or self.area == G.shop_booster) then self.cost = 0 end'
position = 'after'
match_indent = true
payload = '''

if self.config.center.type == 'bunc_blind' and G.GAME.used_vouchers['v_bunc_masquerade'] then
    self.cost = 0
end

'''

# Fanny Pack
[[patches]]
[patches.pattern]
target = 'functions/button_callbacks.lua'
pattern = 'add_tag(_tag.config.ref_table)'
position = 'before'
match_indent = true
payload = '''

if G.GAME.used_vouchers['v_bunc_fanny_pack'] then
    if pseudorandom('fanny_pack'..G.SEED) < G.GAME.probabilities.normal / G.P_CENTERS.v_bunc_fanny_pack.config.extra.odds then
        add_tag(Tag('tag_double'))
    end
end

'''

# Pin Collector 1/2
[[patches]]
[patches.pattern]
target = 'functions/UI_definitions.lua'
pattern = 'function add_tag(_tag)'
position = 'after'
match_indent = true
payload = '''

if G.GAME.used_vouchers['v_bunc_pin_collector'] then
    if _tag.key == 'tag_double' then
        _tag = Tag('tag_bunc_triple')
    end
end

'''

# Pin Collector 2/2
[[patches]]
[patches.pattern]
target = 'tag.lua'
pattern = "if self.name == 'Double Tag' and _context.tag.key ~= 'tag_double' then"
position = 'at'
match_indent = true
payload = '''if self.name == 'Double Tag' and _context.tag.key ~= 'tag_double' and _context.tag.key ~= 'tag_bunc_triple' then'''

# Blind Cards 1/3
[[patches]]
[patches.pattern]
target = 'functions/UI_definitions.lua'
pattern = '''function G.UIDEF.use_and_sell_buttons(card)'''
position = 'after'
match_indent = true
payload = '''

if card.area and card.area == G.pack_cards and card.ability.blind_card then
    return {
        n = G.UIT.ROOT, config = {padding = 0, colour = G.C.CLEAR}, nodes = {
            {n = G.UIT.R, config = {ref_table = card, r = 0.08, padding = 0.1, align = "bm", minw = 0.5 * card.T.w - 0.15, maxw = 0.9 * card.T.w - 0.15, minh = 0.3 * card.T.h, hover = true, shadow = true, colour = G.C.UI.BACKGROUND_INACTIVE, one_press = true, button = 'use_blind_card', func = 'can_use_blind_card'}, nodes = {
                {n=G.UIT.T, config={text = localize('b_select'), colour = G.C.UI.TEXT_LIGHT, scale = 0.45, shadow = true}}
        }},
    }}
end

'''

# Blind Cards 2/3
[[patches]]
[patches.pattern]
target = 'functions/button_callbacks.lua'
pattern = '''G.FUNCS.sell_card = function(e)'''
position = 'before'
match_indent = true
payload = '''

G.FUNCS.can_use_blind_card = function(e)
    e.config.colour = G.C.GREEN
    e.config.button = 'use_blind_card'
end

G.FUNCS.use_blind_card = function(e)
    local card = e.config.ref_table

    local boss = card.ability.blind_card.blind.key

    play_sound('other1')

    e.config.button = nil

    local par = G.blind_select_opts.boss.parent
    G.GAME.round_resets.blind_choices.Boss = boss

    if G.blind_select_opts.boss and par and par.config.object then
        G.blind_select_opts.boss:remove()
        G.blind_select_opts.boss = UIBox{
            T = {par.T.x, 0, 0, 0},
            definition = {
                n = G.UIT.ROOT,
                config = {
                    align = "cm",
                    colour = G.C.CLEAR
                },
                nodes = {UIBox_dyn_container({create_UIBox_blind_choice('Boss')}, false,
                    get_blind_main_colour('Boss'), mix_colours(G.C.BLACK, get_blind_main_colour('Boss'), 0.8))}
            },
            config = {
                align = "bmi",
                offset = {
                    x = 0,
                    y = G.ROOM.T.y + 9
                },
                major = par,
                xy_bond = 'Weak'
            }
        }
        par.config.object = G.blind_select_opts.boss
        par.config.object:recalculate()
        G.blind_select_opts.boss.parent = par
        G.blind_select_opts.boss.alignment.offset.y = 0
    end

    G.PROFILES[G.SETTINGS.profile].blind_cards_used = (G.PROFILES[G.SETTINGS.profile].blind_cards_used or 0) + 1
    if G.PROFILES[G.SETTINGS.profile].blind_cards_used then
        local locked_card

        for i = 1, #G.P_LOCKED do
            locked_card = G.P_LOCKED[i]

            if not locked_card.unlocked and locked_card.check_for_unlock and type(locked_card.check_for_unlock) == 'function' then
                locked_card:check_for_unlock({type = 'use_blind_card', blinds_total = G.PROFILES[G.SETTINGS.profile].blind_cards_used})
            end
        end
    end

    G.FUNCS.end_consumeable(nil, 0.2)
end


'''

# Blind Cards 3/3 (Blind Animation)
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = 'if G.STAGE == G.STAGES.RUN then'
position = 'before'
match_indent = true
payload = '''

if self.ability and self.ability.blind_card then
    local timer = G.TIMERS.REAL * G.ANIMATION_FPS
    local frame_amount = 20
    local wrapped_value = (math.floor(timer) - 1) % frame_amount + 1
    self.children.center:set_sprite_pos({x = wrapped_value, y = self.children.center.sprite_pos.y})
end

'''

# Virtual color, part 1/2
[[patches]]
[patches.pattern]
target = 'globals.lua'
pattern = "RENTAL = HEX('b18f43'),"
position = 'after'
match_indent = true
payload = '''BUNCO_VIRTUAL = HEX('69fa93'),
BUNCO_VIRTUAL_DARK = HEX('4fb66f'),
'''

# Virtual color, part 2/2
[[patches]]
[patches.pattern]
target = 'functions/misc_functions.lua'
pattern = "legendary = G.C.RARITY[4],"
position = 'after'
match_indent = true
payload = '''bunco_virtual = G.C.BUNCO_VIRTUAL,
bunco_virtual_dark = G.C.BUNCO_VIRTUAL_DARK,'''

# Scattering Sticker 1/2
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = 'self.removed = true'
position = 'before'
match_indent = true
payload = '''

local scattering_sticker
if self.ability.bunc_scattering and self.area == G.jokers then scattering_sticker = true end

'''

# Scattering Sticker 2/2
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = 'Moveable.remove(self)'
position = 'after'
match_indent = true
payload = '''

if scattering_sticker then
    if G.jokers and G.jokers.cards and #G.jokers.cards > 0 then
        local random_card
        local joker_table = {}
        for i=1, #G.jokers.cards do
            if not G.jokers.cards[i].ability.eternal then
                table.insert(joker_table, G.jokers.cards[i])
            end
        end
        random_card = joker_table[math.random(#joker_table)]

        if random_card then random_card:start_dissolve() end
    end
end

'''

# Hindered Sticker 1/5
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = 'self:start_dissolve({G.C.GOLD})'
position = 'at'
match_indent = true
payload = '''

if not self.ability.bunc_hindered then
    self:start_dissolve({G.C.GOLD})
else
    self:highlight(false)
    self.ability.bunc_hindered_sold = true
    self.sell_cost = 0
end

'''

# Hindered Sticker 2/5
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = '''if (G.SETTINGS.tutorial_complete or G.GAME.pseudorandom.seed ~= 'TUTORIAL' or G.GAME.round_resets.ante > 1) and'''
position = 'after'
match_indent = true
payload = '''not self.ability.bunc_hindered_sold and'''

# Hindered Sticker 3/5
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = 'elseif self.children.use_button then'
position = 'before'
match_indent = true
payload = '''if self.ability.bunc_hindered_sold and self.children.use_button then self.children.use_button:remove(); self.children.use_button = nil end'''

# Hindered Sticker 4/5
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = 'function Card:calculate_joker(context)'
position = 'before'
match_indent = true
payload = '''

function Card:calculate_hindered()
    if self.ability.bunc_hindered and self.ability.bunc_hindered_sold then
        self:start_dissolve({G.C.GOLD}, nil, 1.6)
    end
end

'''

# Hindered Sticker 5/5
[[patches]]
[patches.pattern]
target = 'functions/state_events.lua'
pattern = 'G.jokers.cards[i]:calculate_perishable()'
position = 'after'
match_indent = true
payload = 'G.jokers.cards[i]:calculate_hindered()'

# Reactive Sticker 1/2
[[patches]]
[patches.pattern]
target = 'card.lua'
pattern = 'function Card:calculate_joker(context)'
position = 'before'
match_indent = true
payload = '''

function Card:calculate_reactive()
    if self.ability.bunc_reactive then
        local debuffed_blinds = 0
        for _, v in pairs(G.GAME.round_resets.blind_states) do
            if v == 'Skipped' then
                debuffed_blinds = debuffed_blinds + 1
            end
        end
        if debuffed_blinds == 1 then
            self:juice_up(0.3, 0.3)
        end
    end
end

'''

# Reactive Sticker 2/2
[[patches]]
[patches.pattern]
target = 'functions/button_callbacks.lua'
pattern = 'G.jokers.cards[i]:calculate_joker({skip_blind = true})'
position = 'before'
match_indent = true
payload = 'G.jokers.cards[i]:calculate_reactive()'

# Eternal Sticker compat
[[patches]]
[patches.pattern]
target = 'functions/common_events.lua'
pattern = 'card:set_eternal(true)'
position = 'at'
match_indent = true
payload = '''

if not (card.ability.bunc_scattering or card.ability.bunc_hindered or card.ability.bunc_reactive) then
    card:set_eternal(true)
end

'''

# Cyan Stake
[[patches]]
[patches.pattern]
target = 'functions/common_events.lua'
pattern = 'if (area == G.shop_jokers) or (area == G.pack_cards) then'
position = 'after'
match_indent = true
payload = '''

if G.GAME.modifiers.enable_scattering_in_shop and pseudorandom(('scattering')..G.GAME.round_resets.ante) > 0.7 then
    SMODS.Stickers['bunc_scattering']:apply(card, true)
end

'''

# Pink Stake
[[patches]]
[patches.pattern]
target = 'functions/common_events.lua'
pattern = 'if (area == G.shop_jokers) or (area == G.pack_cards) then'
position = 'after'
match_indent = true
payload = '''

if G.GAME.modifiers.enable_hindered_in_shop and pseudorandom(('hindered')..G.GAME.round_resets.ante) > 0.7 then
    SMODS.Stickers['bunc_hindered']:apply(card, true)
end

'''

# Magenta Stake
[[patches]]
[patches.pattern]
target = 'functions/common_events.lua'
pattern = 'if (area == G.shop_jokers) or (area == G.pack_cards) then'
position = 'after'
match_indent = true
payload = '''

if G.GAME.modifiers.enable_reactive_in_shop and pseudorandom(('reactive')..G.GAME.round_resets.ante) > 0.7 then
    SMODS.Stickers['bunc_reactive']:apply(card, true)
end

'''