Bunco.lua

BUNCOMOD = {vars = {}, funcs = {bunc_alias_type = type}, content = SMODS.current_mod}
local filesystem = NFS or love.filesystem

local config = BUNCOMOD.content.config

-- Debug message

local function say(message)
    sendDebugMessage('[BUNCO] - '..(message or '???'))
end

-- Talisman-related functions

to_big = to_big or function(x)
    return x
end

to_number = to_number or function(x)
    return x
end

-- Index-based coordinates generation

local function get_coordinates(position, width)
    if width == nil then width = 10 end -- 10 is default for Jokers
    return {x = (position) % width, y = math.floor((position) / width)}
end

local function coordinate_from_atlas_index(position)
    return get_coordinates(position - 1)
end

-- math.huge replacement

local huge_number = 9999

-- Forced messages for evaluation

local function event(config)
    local e = Event(config)
    G.E_MANAGER:add_event(e)
    return e
end

local function big_juice(card)
    card:juice_up(0.7)
end

local function extra_juice(card)
    card:juice_up(0.6, 0.1)
end

local function forced_message(message, card, color, delay, juice)
    if delay == true then
        delay = 0.7 * 1.25
    elseif delay == nil then
        delay = 0
    end

    event({trigger = 'before', delay = delay, func = function()

        if juice then big_juice(juice) end

        card_eval_status_text(
            card,
            'extra',
            nil, nil, nil,
            {message = message, colour = color, instant = true}
        )
        return true
    end})
end

-- Exotic in_pool function

BUNCOMOD.funcs.exotic_in_pool = function()
    if G.GAME and G.GAME.Exotic then return true end
    --In case a Spectrum somehow gets played without enabling exotics, check directly:
    local spectrum_played = false
    if G and G.GAME and G.GAME.hands then
        for k, v in pairs(G.GAME.hands) do
            if string.find(k, "Spectrum", nil, true) then
                if G.GAME.hands[k].played > 0 then
                    spectrum_played = true
                    break
                end
            end
        end
    end

    return spectrum_played
end

-- Dictionary wrapper

function BUNCOMOD.content.process_loc_text()
    G.P_CENTERS['bunc_exotic_cards'] = {key = 'bunc_exotic_cards', set = 'Other'}
end

-- Mod icon

SMODS.Atlas({
    key = 'modicon',
    path = 'Icon/Icon.png',
    px = 32,
    py = 32
})

-- Config globals

BUNCOMOD.vars.jokerlike_consumable_editions = config.jokerlike_consumable_editions

-- Config options

function BUNCOMOD.content.save_config(self)
    SMODS.save_mod_config(self)
end

function BUNCOMOD.content.config_tab()
    return {n = G.UIT.ROOT, config = {r = 0.1, minw = 4, align = "tm", padding = 0.2, colour = G.C.BLACK}, nodes = {
        {n = G.UIT.C, config = {r = 0.1, minw = 4, align = "tl", padding = 0.2, colour = G.C.BLACK}, nodes =
            {
                {
                    n = G.UIT.R,
                    config = {
                        align = "cm",
                        r = 0.1,
                        emboss = 0.1,
                        outline = 1,
                        padding = 0.14
                    },
                    nodes = {
                        create_toggle({
                            label = G.localization.misc.dictionary.bunc_colorful_finishers,
                            info = {
                                G.localization.misc.dictionary.bunc_default_true,
                                '',
                                G.localization.misc.dictionary.bunc_colorful_finishers_desc,
                                G.localization.misc.dictionary.bunc_colorful_finishers_desc_2
                            },
                            ref_table = BUNCOMOD.content.config,
                            ref_value = 'colorful_finishers',
                            callback = function() BUNCOMOD.content:save_config()
                        end})
                    }
                },
                {
                    n = G.UIT.R,
                    config = {
                        align = "cm",
                        r = 0.1,
                        emboss = 0.1,
                        outline = 1,
                        padding = 0.14
                    },
                    nodes = {
                        create_toggle({
                            label = G.localization.misc.dictionary.bunc_high_quality_shaders,
                            info = {
                                G.localization.misc.dictionary.bunc_default_true..', '..G.localization.misc.dictionary.bunc_requires_restart,
                                '',
                                G.localization.misc.dictionary.bunc_high_quality_shaders_desc,
                                G.localization.misc.dictionary.bunc_high_quality_shaders_desc_2
                            },
                            ref_table = BUNCOMOD.content.config,
                            ref_value = 'high_quality_shaders',
                            callback = function() BUNCOMOD.content:save_config()
                        end})
                    }
                },
                {
                    n = G.UIT.R,
                    config = {
                        align = "cm",
                        r = 0.1,
                        emboss = 0.1,
                        outline = 1,
                        padding = 0.14
                    },
                    nodes = {
                        create_toggle({
                            label = G.localization.misc.dictionary.bunc_fixed_sprites,
                            info = {
                                G.localization.misc.dictionary.bunc_default_true..', '..G.localization.misc.dictionary.bunc_requires_restart,
                                '',
                                G.localization.misc.dictionary.bunc_fixed_sprites_desc,
                                G.localization.misc.dictionary.bunc_fixed_sprites_desc_2
                            },
                            ref_table = BUNCOMOD.content.config,
                            ref_value = 'fixed_sprites',
                            callback = function() BUNCOMOD.content:save_config()
                        end})
                    }
                }
            }
        },
        {n = G.UIT.C, config = {r = 0.1, minw = 4, align = "tc", padding = 0.2, colour = G.C.BLACK}, nodes =
            {
                {
                    n = G.UIT.R,
                    config = {
                        align = "cm",
                        r = 0.1,
                        emboss = 0.1,
                        outline = 1,
                        padding = 0.14
                    },
                    nodes = {
                        create_toggle({
                        label = G.localization.misc.dictionary.bunc_gameplay_reworks,
                        info = {
                            G.localization.misc.dictionary.bunc_default_true..', '..G.localization.misc.dictionary.bunc_requires_restart,
                            '',
                            G.localization.misc.dictionary.bunc_gameplay_reworks_desc,
                            G.localization.misc.dictionary.bunc_gameplay_reworks_desc_2
                        },
                        ref_table = BUNCOMOD.content.config,
                        ref_value = 'gameplay_reworks',
                        callback = function() BUNCOMOD.content:save_config()
                            if config.gameplay_reworks then
                                G.P_CENTERS.c_lovers.config.max_highlighted = 2
                            else
                                G.P_CENTERS.c_lovers.config.max_highlighted = 1
                            end
                        end})
                    }
                },
                {
                    n = G.UIT.R,
                    config = {
                        align = "cm",
                        r = 0.1,
                        emboss = 0.1,
                        outline = 1,
                        padding = 0.14
                    },
                    nodes = {
                        create_toggle({
                            label = G.localization.misc.dictionary.bunc_fixed_badges,
                            info = {
                                G.localization.misc.dictionary.bunc_default_false,
                                '',
                                G.localization.misc.dictionary.bunc_fixed_badges_desc,
                                G.localization.misc.dictionary.bunc_fixed_badges_desc_2
                            },
                            ref_table = BUNCOMOD.content.config,
                            ref_value = 'fixed_badges',
                            callback = function() BUNCOMOD.content:save_config()
                        end})
                    }
                },
                {
                    n = G.UIT.R,
                    config = {
                        align = "cm",
                        r = 0.1,
                        emboss = 0.1,
                        outline = 1,
                        padding = 0.14
                    },
                    nodes = {
                        create_toggle({
                            label = G.localization.misc.dictionary.bunc_jokerlike_consumable_editions,
                            info = {
                                G.localization.misc.dictionary.bunc_default_false,
                                '',
                                G.localization.misc.dictionary.bunc_jokerlike_consumable_editions_desc,
                                G.localization.misc.dictionary.bunc_jokerlike_consumable_editions_desc_2
                            },
                            ref_table = BUNCOMOD.content.config,
                            ref_value = 'jokerlike_consumable_editions',
                            callback = function() BUNCOMOD.content:save_config()
                        end})
                    }
                }
            }
        }
    }}
end

-- Audio + Credits tab

G.SETTINGS.SOUND.bunc_trigger_finger_volume = G.SETTINGS.SOUND.bunc_trigger_finger_volume or 100
G.SETTINGS.SOUND.bunc_mousetrap_volume = G.SETTINGS.SOUND.bunc_mousetrap_volume or 100
G.SETTINGS.SOUND.bunc_stylophone_volume = G.SETTINGS.SOUND.bunc_stylophone_volume or 100
SMODS.current_mod.extra_tabs = function()
    local text_scale = 0.6
	return {
		{
			label = localize('b_set_audio'),
			tab_definition_function = function()
				return {n = G.UIT.ROOT, config = {r = 0.1, minw = 4, align = "tm", padding = 0.2, colour = G.C.BLACK}, nodes = {
                    {n=G.UIT.R, config={align = "cm", padding = 0.1, outline_colour = G.C.JOKER_GREY, r = 0.1, outline = 1}, nodes={
                        {n=G.UIT.R, config={align = "tm", padding = 0}, nodes={
                            create_slider({label = G.localization.descriptions.Joker.j_bunc_trigger_finger.name .. " (" .. G.localization.misc.dictionary.bunc_volume .. ")", w = 5, h = 0.4, ref_table = G.SETTINGS.SOUND, ref_value = 'bunc_trigger_finger_volume', min = 0, max = 100}),
                        }},
                        {n=G.UIT.R, config={align = "tm", padding = 0}, nodes={
                            create_slider({label = G.localization.descriptions.Joker.j_bunc_mousetrap.name .. " (" .. G.localization.misc.dictionary.bunc_volume .. ")", w = 5, h = 0.4, ref_table = G.SETTINGS.SOUND, ref_value = 'bunc_mousetrap_volume', min = 0, max = 100}),
                        }},
                        {n=G.UIT.R, config={align = "tm", padding = 0}, nodes={
                            create_slider({label = G.localization.descriptions.Joker.j_bunc_stylophone.name .. " (" .. G.localization.misc.dictionary.bunc_volume .. ")", w = 5, h = 0.4, ref_table = G.SETTINGS.SOUND, ref_value = 'bunc_stylophone_volume', min = 0, max = 100}),
                        }},
                    }}
				}}
			end,
		},
		{
			label = G.localization.misc.dictionary.b_credits,
			tab_definition_function = function()
				return {n = G.UIT.ROOT, config = {r = 0.1, minw = 4, align = "tm", padding = 0.2, colour = G.C.BLACK}, nodes = {
                {n=G.UIT.R, config={align = "cm", padding = 0.1, outline_colour = G.C.JOKER_GREY, r = 0.1, outline = 1}, nodes={
                    {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                        {n=G.UIT.T, config={text = G.localization.misc.dictionary.b_credits, scale = text_scale*0.6, colour = G.C.ORANGE, shadow = true}},
                    }},
                    {n=G.UIT.R, config={align = "tm", padding = 0}, nodes={
                        {n=G.UIT.C, config={align = "tl", padding = 0.05, minw = 2.0}, nodes={
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'Firch', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'RENREN', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'Peas', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'minichibis', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'J.D.', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'Guwahavel', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'Ciirulean', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'ejwu', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'sadlyjustal', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'Domique', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'Haloway', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'hapty', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'Joey', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'hellfirejune', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'Oroshibu', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'women', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'cometz', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'ferrium', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'hippocrunchy', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'Biverom', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'Just_Shrimmp', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'wingedcatgirl', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'Shinosan', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'Mikadoe', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'Lyman', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                        }},
                        {n=G.UIT.C, config={align = "tl", padding = 0.05, minw = 2.0}, nodes={
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'jostro', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'kingbobson', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'aure__', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'itayfeder', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'autumnmood', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'arachneii', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'mysthaps', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'iwas_nevergood', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'chromapie', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'kaishi_', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'Victin', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'sdm_0', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'PinkMaggit', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'Ardub23', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'nh6574', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'jumbocarrot0', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'weird_autumn', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'unascribed', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'itsmythie', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'VisJoker', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'LucasBondDavid', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'JayJayDee', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'Marffe', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'Mr. Clover', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'english5040', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }},
                            {n=G.UIT.R, config={align = "cm", padding = 0}, nodes={
                                {n=G.UIT.T, config={text = 'Cebee', scale = text_scale*0.5, colour = G.C.UI.TEXT_LIGHT, shadow = true}},
                            }}
                        }},
                    }},
                    }}
				}}
			end,
		}
	}
end

-- Shaders

SMODS.Shader({key = 'pinch', path = 'pinch.fs'})

if config.high_quality_shaders then
    local background_shader = NFS.read(BUNCOMOD.content.path..'assets/shaders/background.fs')
    local splash_shader = NFS.read(BUNCOMOD.content.path..'assets/shaders/splash.fs')
    local flame_shader = NFS.read(BUNCOMOD.content.path..'assets/shaders/flame.fs')
    G.SHADERS['background'] = love.graphics.newShader(background_shader)
    G.SHADERS['splash'] = love.graphics.newShader(splash_shader)
    G.SHADERS['flame'] = love.graphics.newShader(flame_shader)
end

-- Fixed badges

SMODS.Consumable:take_ownership('pluto', {
    set_card_type_badge = function(self, card, badges)
        badges[1] = create_badge(config.fixed_badges and localize('k_planet') or localize('k_dwarf_planet'), get_type_colour(self or card.config, card), nil, 1.2)
    end
}, true)

SMODS.Consumable:take_ownership('ceres', {
    set_card_type_badge = function(self, card, badges)
        badges[1] = create_badge(config.fixed_badges and localize('k_planet_q') or localize('k_dwarf_planet'), get_type_colour(self or card.config, card), nil, 1.2)
    end
}, true)

SMODS.Consumable:take_ownership('eris', {
    set_card_type_badge = function(self, card, badges)
        badges[1] = create_badge(config.fixed_badges and localize('k_planet_q') or localize('k_dwarf_planet'), get_type_colour(self or card.config, card), nil, 1.2)
    end
}, true)

-- Fixed sprites

SMODS.Atlas({key = 'bunco_resprites_jokers', path = 'Resprites/Jokers.png', px = 71, py = 95})
SMODS.Atlas({key = 'bunco_resprites_tarots', path = 'Resprites/Tarots.png', px = 71, py = 95})
SMODS.Atlas({key = 'bunco_resprites_planets', path = 'Resprites/Planets.png', px = 71, py = 95})
SMODS.Atlas({key = 'bunco_resprites_spectrals', path = 'Resprites/Spectrals.png', px = 71, py = 95})

function use_fixed_sprite_atlas()
    return config.fixes_sprites and not next(SMODS.find_mod("malverk"))
end

if config.fixed_sprites then

    -- -- High contrast

    G.C['SO_1']['Spades'] = HEX('3c4368')

    -- G.C.SUITS = G.C["SO_" .. (G.SETTINGS.colourblind_option and 2 or 1)]

    if not next(SMODS.find_mod("malverk")) then

        -- Jokers

        SMODS.Joker:take_ownership('juggler', {
            pos = coordinate_from_atlas_index(1),
            atlas = 'bunco_resprites_jokers'
        }, true)

        SMODS.Joker:take_ownership('drunkard', {
            pos = coordinate_from_atlas_index(2),
            atlas = 'bunco_resprites_jokers'
        }, true)

        SMODS.Joker:take_ownership('acrobat', {
            pos = coordinate_from_atlas_index(3),
            atlas = 'bunco_resprites_jokers'
        }, true)

        SMODS.Joker:take_ownership('credit_card', {
            pos = coordinate_from_atlas_index(4),
            atlas = 'bunco_resprites_jokers'
        }, true)

        SMODS.Joker:take_ownership('troubadour', {
            pos = coordinate_from_atlas_index(5),
            atlas = 'bunco_resprites_jokers'
        }, true)

        SMODS.Joker:take_ownership('even_steven', {
            pos = coordinate_from_atlas_index(6),
            atlas = 'bunco_resprites_jokers'
        }, true)

        SMODS.Joker:take_ownership('odd_todd', {
            pos = coordinate_from_atlas_index(7),
            atlas = 'bunco_resprites_jokers'
        }, true)

        SMODS.Joker:take_ownership('fibonacci', {
            pos = coordinate_from_atlas_index(8),
            atlas = 'bunco_resprites_jokers'
        }, true)

        SMODS.Joker:take_ownership('drivers_license', {
            pos = coordinate_from_atlas_index(9),
            atlas = 'bunco_resprites_jokers'
        }, true)

        SMODS.Joker:take_ownership('gift', {
            pos = coordinate_from_atlas_index(10),
            atlas = 'bunco_resprites_jokers'
        }, true)

        SMODS.Joker:take_ownership('flash', {
            pos = coordinate_from_atlas_index(11),
            atlas = 'bunco_resprites_jokers'
        }, true)

        SMODS.Joker:take_ownership('ramen', {
            pos = coordinate_from_atlas_index(12),
            atlas = 'bunco_resprites_jokers'
        }, true)

        SMODS.Joker:take_ownership('selzer', {
            pos = coordinate_from_atlas_index(13),
            atlas = 'bunco_resprites_jokers'
        }, true)

        SMODS.Joker:take_ownership('scholar', {
            pos = coordinate_from_atlas_index(14),
            atlas = 'bunco_resprites_jokers'
        }, true)

        -- Consumables

        SMODS.Consumable:take_ownership('fool', {
            pos = coordinate_from_atlas_index(1),
            atlas = 'bunco_resprites_tarots'
        }, true)

        SMODS.Consumable:take_ownership('lovers', {
            pos = coordinate_from_atlas_index(2),
            atlas = 'bunco_resprites_tarots'
        }, true)

        SMODS.Consumable:take_ownership('chariot', {
            pos = coordinate_from_atlas_index(3),
            atlas = 'bunco_resprites_tarots'
        }, true)

        SMODS.Consumable:take_ownership('wheel_of_fortune', {
            pos = coordinate_from_atlas_index(4),
            atlas = 'bunco_resprites_tarots'
        }, true)

        SMODS.Consumable:take_ownership('tower', {
            pos = coordinate_from_atlas_index(5),
            atlas = 'bunco_resprites_tarots'
        }, true)

        SMODS.Consumable:take_ownership('moon', {
            pos = coordinate_from_atlas_index(6),
            atlas = 'bunco_resprites_tarots'
        }, true)

        SMODS.Consumable:take_ownership('world', {
            pos = coordinate_from_atlas_index(7),
            atlas = 'bunco_resprites_tarots'
        }, true)

        SMODS.Consumable:take_ownership('soul', {
            pos = coordinate_from_atlas_index(1),
            atlas = 'bunco_resprites_spectrals'
        }, true)

        SMODS.Consumable:take_ownership('ceres', {
            pos = coordinate_from_atlas_index(1),
            atlas = 'bunco_resprites_planets'
        }, true)

        SMODS.Consumable:take_ownership('mercury', {
            pos = coordinate_from_atlas_index(2),
            atlas = 'bunco_resprites_planets'
        }, true)

        SMODS.Consumable:take_ownership('uranus', {
            pos = coordinate_from_atlas_index(3),
            atlas = 'bunco_resprites_planets'
        }, true)

        SMODS.Consumable:take_ownership('pluto', {
            pos = coordinate_from_atlas_index(4),
            atlas = 'bunco_resprites_planets'
        }, true)

        SMODS.Consumable:take_ownership('incantation', {
            pos = coordinate_from_atlas_index(2),
            atlas = 'bunco_resprites_spectrals'
        }, true)

        SMODS.Consumable:take_ownership('black_hole', {
            pos = coordinate_from_atlas_index(3),
            atlas = 'bunco_resprites_spectrals'
        })

    end

    if next(SMODS.find_mod("malverk")) then
        AltTexture({
            key = 'tarots_fixed_sprites',
            set = 'Tarot',
            path = 'Resprites/Tarots.png',
            keys = {
            'c_fool',
            'c_lovers',
            'c_chariot',
            'c_wheel_of_fortune',
            'c_tower',
            'c_moon',
            'c_world',
            },
            loc_txt = {
            name = 'Tarot Fixes'
            }
        })
        AltTexture({
            key = 'planets_fixed_sprites',
            set = 'Planet',
            path = 'Resprites/Planets.png',
            keys = {
            'c_ceres',
            'c_mercury',
            'c_uranus',
            'c_pluto',
            },
            loc_txt = {
            name = 'Planet Fixes'
            }
        })
        AltTexture({
            key = 'spectrals_fixed_sprites',
            set = 'Spectral',
            path = 'Resprites/Spectrals.png',
            keys = {
            'c_soul',
            'c_incantation',
            'c_black_hole'
            },
            loc_txt = {
            name = 'Spectral Fixes'
            }
        })
        AltTexture({
            key = 'jokers_fixed_sprites',
            set = 'Joker',
            path = 'Resprites/Jokers.png',
            keys = {
            'j_juggler',
            'j_drunkard',
            'j_acrobat',
            'j_credit_card',
            'j_troubadour',
            'j_even_steven',
            'j_odd_todd',
            'j_fibonacci',
            'j_drivers_license',
            'j_gift',
            'j_flash',
            'j_ramen',
            'j_selzer',
            'j_scholar'
            },
            loc_txt = {
            name = 'Joker Fixes'
            }
        })
        
        TexturePack({
            key = 'bunc_fixed_sprites',
            textures = {
            'bunc_jokers_fixed_sprites',
            'bunc_tarots_fixed_sprites',
            'bunc_planets_fixed_sprites',
            'bunc_spectrals_fixed_sprites',
            },
            loc_txt = {
            name = 'Bunco Resprites',
            text = {'Port of Bunco sprite fixes'}
            }
        })
    end

end

-- Text icons

local font_replacement = NFS.read(BUNCOMOD.content.path..'assets/fonts/font.ttf')
love.filesystem.write('font_replacement.ttf', font_replacement)
G.FONTS[1].FONT = love.graphics.newFont('font_replacement.ttf', G.TILESIZE * 10)
love.filesystem.remove('font_replacement.ttf')

-- Gameplay reworks

if config.gameplay_reworks then

    BUNCOMOD.content.config.gameplay_reworks = true

    G.P_CENTERS.c_lovers.config.max_highlighted = 2

    SMODS.Joker:take_ownership('luchador', {
        loc_vars = function(self, info_queue)
            info_queue[#info_queue + 1] = {key = 'tag_bunc_breaking', set = 'Tag'}
            return {key = 'j_bunc_luchador'}
        end,
        calculate = function(self, card, context)
            if context.selling_self then
                G.E_MANAGER:add_event(Event({
                    func = (function()
                        add_tag(Tag('tag_bunc_breaking'))
                        play_sound('generic1', 0.9 + math.random() * 0.1, 0.8)
                        play_sound('holo1', 1.2 + math.random() * 0.1, 0.4)

                        -- Trigger immediate tags
                        G.E_MANAGER:add_event(Event({
                            trigger = 'immediate',
                            func = function()
                                for i = 1, #G.GAME.tags do
                                    G.GAME.tags[i]:apply_to_run({ type = 'immediate' })
                                end
                                return true
                            end
                        }))
                        return true
                    end)
                }))
            end
        end
    })

    SMODS.Joker:take_ownership('red_card', {
        loc_vars = function(self, info_queue)
            return {key = 'j_bunc_red_card'}
        end,
        calculate = function(self, card, context)
            if context.skipping_booster and not context.blueprint then
                card.ability.mult = card.ability.mult + (card.ability.extra * G.GAME.pack_choices)
                return {
                    message = localize{type = 'variable', key = 'a_mult', vars = {card.ability.extra * G.GAME.pack_choices}},
                    colour = G.C.RED,
                    delay = 0.45
                }
            end
        end
    })

    SMODS.Tag:take_ownership('boss', {
        loc_vars = function(self, info_queue)
            info_queue[#info_queue + 1] = {key = 'p_bunc_blind', set = 'Other', vars = {G.P_CENTERS.p_bunc_blind_1.config.extra}}
            return {key = 'tag_bunc_boss'}
        end,
        config = {type = 'new_blind_choice'},
        apply = function(self, tag, context)
            if context.type == self.config.type then
                G.CONTROLLER.locks[tag.ID] = true
                tag:yep('+', G.C.SECONDARY_SET.Spectral, function()
                    local key = 'p_bunc_blind_'..(math.random(4))
                    local card = Card(G.play.T.x + G.play.T.w/2 - G.CARD_W*1.27/2,
                    G.play.T.y + G.play.T.h/2-G.CARD_H*1.27/2, G.CARD_W*1.27, G.CARD_H*1.27, G.P_CARDS.empty, G.P_CENTERS[key], {bypass_discovery_center = true, bypass_discovery_ui = true})
                    card.cost = 0
                    card.from_tag = true
                    G.FUNCS.use_card({config = {ref_table = card}})
                    card:start_materialize()
                    G.CONTROLLER.locks[tag.ID] = nil
                    return true
                end)
                tag.triggered = true
                return true
            end
        end
    })

    SMODS.Tag:take_ownership('d_six', {
        loc_vars = function(self, info_queue)
            return {key = 'tag_bunc_d_six'}
        end,
        config = {type = 'shop_final_pass'},
        apply = function(self, tag, context)
            if context.type == self.config.type then
                tag:yep('+', G.C.GREEN, function()
                    return true
                end)

                G.GAME.current_round.free_rerolls = math.max(G.GAME.current_round.free_rerolls + 1, 0)
                calculate_reroll_cost(true)

                tag.triggered = true
                return true
            end
        end
    })

    -- Glitter-related

    SMODS.Consumable:take_ownership('wheel_of_fortune', {
        loc_vars = function(self, info_queue)

            info_queue[#info_queue+1] = G.P_CENTERS.e_foil
            info_queue[#info_queue+1] = G.P_CENTERS.e_holo
            info_queue[#info_queue+1] = G.P_CENTERS.e_polychrome
            info_queue[#info_queue+1] = G.P_CENTERS.e_bunc_glitter

            local vars = {SMODS.get_probability_vars(card, 1, self.config.extra, 'wheel_of_fortune')}
            return {key = 'c_bunc_wheel_of_fortune', vars = vars}
        end,
        pos = use_fixed_sprite_atlas() and coordinate_from_atlas_index(4) or nil,
        atlas = use_fixed_sprite_atlas() and 'bunco_resprites_tarots' or nil
    })

    SMODS.Consumable:take_ownership('aura', {
        loc_vars = function(self, info_queue)

            info_queue[#info_queue+1] = G.P_CENTERS.e_foil
            info_queue[#info_queue+1] = G.P_CENTERS.e_holo
            info_queue[#info_queue+1] = G.P_CENTERS.e_polychrome
            info_queue[#info_queue+1] = G.P_CENTERS.e_bunc_glitter

            return {key = 'c_bunc_aura'}
        end
    })
end

-- Temporary extra chips

local bunc_original_end_round = end_round
function end_round()
    for _, v in ipairs(G.playing_cards) do
        if v.ability and type(v.ability) == 'table' and v.ability.temporary_extra_chips then
            v.ability.temporary_extra_chips = nil
        end
    end
    bunc_original_end_round()
end

local Card_get_chip_bonus = Card.get_chip_bonus
function Card:get_chip_bonus()
    return Card_get_chip_bonus(self) + (self.ability and type(self.ability) == 'table' and not self.debuff and self.ability.temporary_extra_chips or 0)
end

-- Miscellaneous stuff

-- Post-effect card eval (for specific cases)

function post_eval_card(card, context)
    if not card then return end
    if card.ability.set ~= 'Joker' and card.debuff then return {} end
    context = context or {}
    local ret = {}

    if card.ability.set == 'Enhanced' and card.config.center.post_effect then
        local enhancement = card:calculate_enhancement(context)
        if enhancement then
            ret.enhancement = enhancement
        end
    end

    return ret
end

local bunc_original_calculate_main_scoring = SMODS.calculate_main_scoring
function SMODS.calculate_main_scoring(context, scoring_hand)
    bunc_original_calculate_main_scoring(context, scoring_hand)

    -- Post-scoring

    for _, card in ipairs(scoring_hand or context.cardarea.cards) do
        local post_context = context
        post_context.main_scoring = true
        post_context.post_effect = true
        post_context.cardarea = G.play
        post_context.full_hand = G.play.cards
        post_context.scoring_hand = scoring_hand
        SMODS.trigger_effects({post_eval_card(card, post_context)}, card)
    end
end

-- Repetitions unlocking

local bunc_original_calculate_repetitions = SMODS.calculate_repetitions
SMODS.calculate_repetitions = function(card, context, reps)
    bunc_original_calculate_repetitions(card, context, reps)

    check_for_unlock({type = 'repetition', repetition_amount = #reps - 1})
end

-- Various on-money-gain functions

table.insert(SMODS.calculation_keys, "bunc_new_dollars_mod")
table.insert(SMODS.other_calculation_keys, "bunc_new_dollars_mod")
local bunc_original_smods_calculate_individal_effect = SMODS.calculate_individual_effect
SMODS.calculate_individual_effect = function(effect, scored_card, key, amount, from_edition)
    
    if key == "bunc_new_dollars_mod" then
        return { [key] = amount }
    end

    return bunc_original_smods_calculate_individal_effect(effect, scored_card, key, amount, from_edition)
end

local bunc_original_ease_dollars = ease_dollars
function ease_dollars(mod, instant)
    if G.GAME.Trident and (to_big(mod) <= to_big(0)) then -- Vermilion Trident 1/2
        G.GAME.ante_purchases = (G.GAME.ante_purchases or 0) + 1
    end
    
    G.GAME.bunc_money_spend_this_round = G.GAME.bunc_money_spend_this_round or 0 -- Money spent in one shop unlock 1/2
    if to_big(mod) < to_big(0) then
        G.GAME.bunc_money_spend_this_round = G.GAME.bunc_money_spend_this_round - mod
        check_for_unlock({type = 'round_spend_money', round_spend_money = G.GAME.bunc_money_spend_this_round})
    end

    local ret = SMODS.calculate_context({
        bunc_pre_money_change = true,
        mod = mod,
        sign = (to_big(mod) < to_big(0) and -1 or to_big(mod) > to_big(0) and 1 or 0)
    })
    mod = ret.calculated and to_big(ret.bunc_new_dollars_mod) or mod

    if to_big(mod) == to_big(0) then return end

    bunc_original_ease_dollars(mod, instant)

    if instant then
        SMODS.calculate_context({
            bunc_money_change = true,
            mod = mod, 
            sign = (to_big(mod) < to_big(0) and -1 or to_big(mod) > to_big(0) and 1 or 0)
        })
        if G.GAME.round_resets.blind_choices.Boss == "bl_bunc_stone" then
            BUNCOMOD.funcs.bunc_refresh_boss_blind()
        end
    else
        G.E_MANAGER:add_event(Event({
        trigger = 'immediate',
        func = function()
            SMODS.calculate_context({
                bunc_money_change = true, 
                mod = mod, 
                sign = (to_big(mod) < to_big(0) and -1 or to_big(mod) > to_big(0) and 1 or 0)
            })
            if G.GAME.round_resets.blind_choices.Boss == "bl_bunc_stone" then
                BUNCOMOD.funcs.bunc_refresh_boss_blind()
            end
            return true
        end
        }))
    end

end

local bunc_original_game_update = Game.update
function Game:update(dt)

    -- The 8

    if G.GAME then
        G.GAME.THE_8_BYPASS = false
    end

    -- The Wind

    if G.GAME and G.GAME.blind and G.GAME.blind.name == 'bl_bunc_wind' and G.GAME.blind.ready and not G.GAME.blind.disabled then
        if G.jokers then
            for i = 1, #G.jokers.cards do
                G.GAME.blind:debuff_card(G.jokers.cards[i])
            end
        end
    end

    -- Reactive

    if G.jokers then
        for i = 1, #G.jokers.cards do
            if G.jokers.cards[i].ability.bunc_reactive then
                G.GAME.blind:debuff_card(G.jokers.cards[i])
            end
        end
    end

    -- (Vermilion Trident 2/2)
    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
        G.GAME.ante_purchases = 0
    end

    bunc_original_game_update(self, dt)
end

function BUNCOMOD.content.set_debuff(card)

    -- Fluorescent edition

    if card.edition and card.edition.bunc_fluorescent then
        return 'prevent_debuff'
    end

    -- Card position

    local my_pos = nil
    for i = 1, #G.jokers.cards do
        if G.jokers.cards[i] == card then my_pos = i; break end
    end

    -- The Wind

    if G.GAME.blind.name == 'bl_bunc_wind' and G.GAME.blind.ready and not G.GAME.blind.disabled and my_pos == 1 then
        return true
    end

    -- The Prince

    if G.GAME.blind.name == 'bl_bunc_prince' and G.GAME.blind.ready and not G.GAME.blind.disabled and card.area == G.jokers then
        return true
    end

    -- Gameplan

    if my_pos then
        if G.jokers.cards[my_pos - 1] and G.jokers.cards[my_pos - 1].config.center.key == 'j_bunc_gameplan' and not G.jokers.cards[my_pos - 1].debuff then return true end
        if G.jokers.cards[my_pos + 1] and G.jokers.cards[my_pos + 1].config.center.key == 'j_bunc_gameplan' and not G.jokers.cards[my_pos + 1].debuff then return true end
    end

    -- Reactive

    local reactive_condition
    for _, v in pairs(G.GAME.round_resets.blind_states) do
        if v == 'Skipped' then
            reactive_condition = true
        end
    end
    for i = 1, #G.jokers.cards do
        if card == G.jokers.cards[i] and G.jokers.cards[i].ability.bunc_reactive then
            if not reactive_condition then
                return true
            end
        end

        -- Conquest

        if card.ability.bunc_conquest_chosen then
            return true
        end
    end

    return false
end

local bunc_original_start_run = Game.start_run
function Game:start_run(args)
    bunc_original_start_run(self, args)

    local sledgehammers = SMODS.find_card('j_bunc_sledgehammer')
    for _, card in ipairs(sledgehammers) do
        G.P_CENTERS.m_glass.config.Xmult = G.P_CENTERS.m_glass.config.Xmult + card.ability.extra.plus_xmult
    end
    if #sledgehammers >= 1 then
        G.P_CENTERS.m_glass.config.extra = G.P_CENTERS.m_glass.config.extra / G.P_CENTERS['j_bunc_sledgehammer'].config.extra.div_chance_denom
    end
end

SMODS.Tag:take_ownership('double', {
    loc_vars = function(self)
        if G.GAME and G.GAME.used_vouchers['v_bunc_pin_collector'] then
            return {key = 'tag_bunc_double'}
        end
    end,
}, true)

-- All in Jest compat
-- AiJ implemented this in a way that usually specific compat isn't required
-- However in this case I did weird stuff, so putting in a specific fix
-- Used in Prehistoric Joker
aij_ids_op = next(SMODS.find_mod("allinjest")) and ids_op or function (card, op, b)
    return card:get_id() == b
end

-- Joker creation setup

SMODS.Atlas({key = 'bunco_jokers', path = 'Jokers/Jokers.png', px = 71, py = 95})
SMODS.Atlas({key = 'bunco_jokers_exotic', path = 'Jokers/JokersExotic.png', px = 71, py = 95})
SMODS.Atlas({key = 'bunco_jokers_legendary', path = 'Jokers/JokersLegendary.png', px = 71, py = 95})
SMODS.Atlas({key = 'bunco_jokers_the_joker', path = 'Jokers/JokerBlind.png', px = 71, py = 95})
SMODS.Atlas({key = 'bunco_jokers_taped', path = 'Jokers/JokerTaped.png', px = 127, py = 113})
SMODS.Atlas({key = 'bunco_jokers_headache', path = 'Jokers/JokerHeadache.png', px = 71, py = 95})
SMODS.Atlas({key = 'bunco_jokers_winking', path = 'Jokers/JokerWinking.png', px = 71, py = 95})
SMODS.Atlas({key = 'bunco_jokers_border', path = 'Jokers/JokerBorder.png', px = 71, py = 95})
SMODS.Atlas({key = 'settings_icon', path = 'settings.png', px = 32, py = 32})

SMODS.Sound({key = 'gunshot', path = 'gunshot.ogg'})
SMODS.Sound({key = 'mousetrap', path = 'mousetrap.ogg'})
SMODS.Sound({key = 'spade', path = 'spade.ogg'})
SMODS.Sound({key = 'club', path = 'club.ogg'})
SMODS.Sound({key = 'heart', path = 'heart.ogg'})
SMODS.Sound({key = 'diamond', path = 'diamond.ogg'})
SMODS.Sound({key = 'fleuron', path = 'fleuron.ogg'})
SMODS.Sound({key = 'halberd', path = 'halberd.ogg'})
SMODS.Sound({key = 'stone', path = 'stone.ogg'})
SMODS.Sound({key = 'paperback_crown', path = 'crown.ogg'})
SMODS.Sound({key = 'paperback_star', path = 'star.ogg'})
SMODS.Sound({key = 'minty_3', path = 'meow3.wav'})

SMODS.Shader({key = 'headache', path = 'headache.fs'})

local function bunc_define_joker(joker)

    -- Sprite position

    local width = 10 -- Width of the spritesheet (in Jokers)

        -- Soul sprite

        if joker.rarity == 'Legendary' then
            joker.soul = get_coordinates(joker.position) -- Calculates coordinates based on the position variable
        end

    joker.position = get_coordinates(joker.position - 1)

    -- Sprite atlas

    local atlas

    if joker.type == nil then
        atlas = 'bunco_jokers'
    elseif joker.type == 'Exotic' then
        atlas = 'bunco_jokers_exotic'
    end

    if joker.rarity == 'Legendary' then
        atlas = 'bunco_jokers_legendary'
    end

    -- Key generation from name

    local key = string.gsub(string.lower(joker.name), '%s', '_') -- Removes spaces and uppercase letters

    -- Rarity conversion

    if joker.rarity == 'Common' then
        joker.rarity = 1
    elseif joker.rarity == 'Uncommon' then
        joker.rarity = 2
    elseif joker.rarity == 'Rare' then
        joker.rarity = 3
    elseif joker.rarity == 'Legendary' then
        joker.rarity = 4
    end

    -- Config values

    if joker.vars == nil then joker.vars = {} end

    joker.config = {extra = {}}

    for _, kv_pair in ipairs(joker.vars) do
        -- kv_pair is {a = 1}
        local k, v = next(kv_pair)
        joker.config.extra[k] = v
    end

    -- Exotic Joker pool isolation

    local pool

    if joker.type == 'Exotic' then
        pool = BUNCOMOD.funcs.exotic_in_pool
    end

    -- Joker creation

    SMODS.Joker{
        name = joker.name,
        key = key,

        atlas = joker.custom_atlas or atlas,
        pos = joker.position,
        soul_pos = joker.soul,

        rarity = joker.rarity,
        cost = joker.cost,

        unlocked = joker.unlocked,
        check_for_unlock = joker.check_for_unlock,
        unlock_condition = joker.unlock_condition,
        discovered = false,

        blueprint_compat = joker.blueprint,
        eternal_compat = joker.eternal,
        perishable_compat = joker.perishable,

        pools = joker.pools,

        process_loc_text = joker.process_loc_text,

        config = joker.custom_config or joker.config,
        loc_vars = joker.custom_vars or function(self, info_queue, card)

            -- Localization values

            local vars = {}

            for _, kv_pair in ipairs(joker.vars) do
                -- kv_pair is {a = 1}
                local k, v = next(kv_pair)
                -- k is `a`, v is `1`
                table.insert(vars, card.ability.extra[k])
            end

            return {vars = vars}
        end,
        locked_loc_vars = joker.locked_vars,

        calculate = joker.calculate,
        update = joker.update,
        remove_from_deck = joker.remove,
        add_to_deck = joker.add,
        set_ability = joker.set_ability,
        set_sprites = joker.set_sprites,
        load = joker.load,
        in_pool = joker.custom_in_pool or pool,

        effect = joker.effect
    }
    if joker.drawsteps then
        for index, drawstep in ipairs(joker.drawsteps) do
            drawstep.key = key..'_'..index
            SMODS.DrawStep(drawstep)
        end
    end
end

-- Jokers

local bunc_cassette_sprite_change = function(card)
    local coord = 1

    if BUNCOMOD.funcs.exotic_in_pool() then
        coord = coord + 70
    end

    if card.ability and card.ability.extra and card.ability.extra.side then
        if card.ability.extra.side == 'B' then
            coord = coord + 1
        end
    end

    card.children.center:set_sprite_pos(coordinate_from_atlas_index(coord))
end
bunc_define_joker({ -- Cassette
    name = 'Cassette', position = 1,
    vars = {{chips = 45}, {mult = 6}, {side = 'A'}},
    custom_vars = function(self, info_queue, card)
        local vars = {card.ability.extra.chips, card.ability.extra.mult}

        local scale = 0.75

        local flip_nodes = {}
        localize{type = 'descriptions', set = 'Joker', key = 'j_bunc_cassette_extra', nodes = flip_nodes, vars = {}, scale = scale}

        local side_nodes = {}
        localize{type = 'descriptions', set = 'Joker', key = 'j_bunc_cassette_'..(card.ability.extra.side == 'A' and 'b' or 'a'), nodes = side_nodes, vars = vars, scale = scale}

        local main_end = {
            {n = G.UIT.R, config = {align = "cm", padding = 0.08}, nodes = {
                {n = G.UIT.R, config = {align = "cm"}, nodes =
                    flip_nodes[1]
                },
                {n = G.UIT.R, config = {align = "cm", padding = 0.08, colour = G.C.UI.BACKGROUND_DARK, r = 0.05}, nodes = {
                    {n = G.UIT.R, config = {align = "cm"}, nodes = {
                        {n = G.UIT.O, config = {
                            object = DynaText({string = {G.localization.misc.dictionary['bunc_'..(card.ability.extra.side == 'A' and 'b' or 'a')..'_side']}, colours = {G.C.WHITE},
                            scale = 0.32 * (scale) * G.LANG.font.DESCSCALE})
                        }},
                    }},
                    {n = G.UIT.R, config = {align = "cm", outline_colour = G.C.UI.BACKGROUND_WHITE, colour = G.C.UI.BACKGROUND_WHITE, outline = 1, r = 0.05, padding = 0.05}, nodes = {
                        {n = G.UIT.R, config = {align = "cm"}, nodes =
                            side_nodes[1]
                        },
                        {n = G.UIT.R, config = {align = "cm"}, nodes =
                            side_nodes[2]
                        }
                    }}
                }},
            }}
        }

        if card.ability.extra.side == 'A' then
            if next(SMODS.find_mod("paperback")) then
                info_queue[#info_queue + 1] = PB_UTIL.suit_tooltip('light')
            else
                if card.area and card.area.config.collection and G.P_CENTERS['b_bunc_fairy'].unlocked then
                    info_queue[#info_queue+1] = {set = 'Other', key = 'bunc_light_suits_exotic'}
                else
                    if G.GAME and G.GAME.Exotic then
                        info_queue[#info_queue+1] = {set = 'Other', key = 'bunc_light_suits_exotic'}
                    else
                        info_queue[#info_queue+1] = {set = 'Other', key = 'bunc_light_suits'}
                    end
                end
            end

            return {key = self.key..'_a',
            main_end = main_end,
            vars = vars}
        else
            if next(SMODS.find_mod("paperback")) then
                info_queue[#info_queue + 1] = PB_UTIL.suit_tooltip('dark')
            else
                if card.area and card.area.config.collection and G.P_CENTERS['b_bunc_fairy'].unlocked then
                    info_queue[#info_queue+1] = {set = 'Other', key = 'bunc_dark_suits_exotic'}
                else
                    if G.GAME and G.GAME.Exotic then
                        info_queue[#info_queue+1] = {set = 'Other', key = 'bunc_dark_suits_exotic'}
                    else
                        info_queue[#info_queue+1] = {set = 'Other', key = 'bunc_dark_suits'}
                    end
                end
            end

            return {key = self.key..'_b',
            main_end = main_end,
            vars = vars}
        end
    end,
    rarity = 'Uncommon', cost = 5,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if context.pre_discard and not context.blueprint then
            card:flip()
        end

        if context.flip and not context.blueprint and context.card_flipped == card then
            if card.ability.extra.side == 'A' then
                card.ability.extra.side = 'B'
            else
                card.ability.extra.side = 'A'
            end
            return {
                message = G.localization.misc.dictionary['bunc_'..(card.ability.extra.side == 'A' and 'a' or 'b')..'_side'],
                colour = G.C.RED
            }
        end

        if context.individual and context.cardarea == G.play then

            local other_card = context.other_card
            local side = card.ability.extra.side

            if other_card:is_suit('Hearts') or other_card:is_suit('Diamonds') or other_card:is_suit('bunc_Fleurons') then
                if side == 'A' then
                    return {
                        chips = card.ability.extra.chips
                    }
                end
            end

            if other_card:is_suit('Spades') or other_card:is_suit('Clubs') or other_card:is_suit('bunc_Halberds') then
                if side == 'B' then
                    return {
                        mult = card.ability.extra.mult
                    }
                end
            end
        end
    end,
    update = function(self, card)
        if card.VT.w <= 0 then
            bunc_cassette_sprite_change(card)
        end
    end,
    set_sprites = function(self, card, front)
        if self.discovered or card.bypass_discovery_center then
            bunc_cassette_sprite_change(card)
        end
    end
})

bunc_define_joker({ -- Mosaic
    name = 'Mosaic', position = 3,
    vars = {{mult = 6}},
    rarity = 'Uncommon', cost = 4,
    blueprint = true, eternal = true, perishable = true,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'hand_contents' then
            local tally = 0
            for j = 1, #args.cards do
                if args.cards[j].config.center == G.P_CENTERS.m_stone then
                    tally = tally + 1
                end
            end
            if tally >= 5 then
                unlock_card(self)
            end
        end
    end,
    custom_in_pool = function()
        local condition = false
        if G.playing_cards then
            for k, v in pairs(G.playing_cards) do
                if v.config.center == G.P_CENTERS.m_stone then condition = true break end
            end
        end
        return condition
    end,
    calculate = function(self, card, context)
        if context.individual and context.cardarea == G.play then
            if context.other_card.config.center == G.P_CENTERS.m_stone then
                return {
                    mult = card.ability.extra.mult
                }
            end
        end
    end
})

bunc_define_joker({ -- Voxel
    name = 'Voxel', position = 4,
    vars = {{base = 3}, {bonus = 0.1}, {xmult = 3}, {tally = 0}, {unlock = 10}},
    locked_vars = function(self, info_queue, card)
        return {vars = {self.config.extra.unlock}}
    end,
    rarity = 'Uncommon', cost = 5,
    blueprint = true, eternal = true, perishable = true,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'modify_deck' then
            local count = 0
            for _, v in pairs(G.playing_cards) do
                if v.config.center ~= G.P_CENTERS.c_base then count = count + 1 end
            end
            if count >= self.config.extra.unlock then
                unlock_card(self)
            end
        end
    end,
    calculate = function(self, card, context)
        if context.joker_main then
            if card.ability.extra.xmult ~= 1 then
                return {
                    xmult = card.ability.extra.xmult
                }
            end
        end
    end,
    update = function(self, card)
        if G.playing_cards ~= nil then
            card.ability.extra.tally = 0

            for k, v in pairs(G.playing_cards) do
                if v.config.center ~= G.P_CENTERS.c_base then card.ability.extra.tally = card.ability.extra.tally + 1 end
            end

            if (card.ability.extra.base - card.ability.extra.tally * card.ability.extra.bonus) >= 1 then
                card.ability.extra.xmult = card.ability.extra.base - card.ability.extra.tally * card.ability.extra.bonus
            else
                card.ability.extra.xmult = 1
            end
        end
    end
})

bunc_define_joker({ -- Crop Circles
    name = 'Crop Circles', position = 5,
    rarity = 'Common', cost = 4,
    custom_vars = function(self, info_queue, card)
        if card.area and card.area.config.collection and G.P_CENTERS['b_bunc_fairy'].unlocked then
            return {key = self.key..'_exotic'}
        else
            if G.GAME and G.GAME.Exotic then
                return {key = self.key..'_exotic'}
            end
        end
    end,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if context.individual and context.cardarea == G.play then

            local other_card = context.other_card

            local rank_mult = 0
            local suit_mult = 0

            if not SMODS.has_no_suit(other_card) then
                if other_card.base.suit == "bunc_Fleurons" then
                    suit_mult = suit_mult + 4
                elseif other_card.base.suit == "Clubs" then
                    suit_mult = suit_mult + 3
                end
            end

            if not SMODS.has_no_rank(other_card) then
                if other_card:get_id() == 8 then
                    rank_mult = rank_mult + 2
                elseif other_card:get_id() == 12 or other_card:get_id() == 10 or other_card:get_id() == 9 or other_card:get_id() == 6 then
                    rank_mult = rank_mult + 1
                end
            end

            if (suit_mult + rank_mult) > 0 then
                if not context.blueprint and BUNCOMOD.funcs.exotic_in_pool() then
                    event({
                        blocking = false,
                        func = function()
                            card.children.center:set_sprite_pos(coordinate_from_atlas_index(73))
                            return true
                        end
                    })
                end
                return {
                    mult = suit_mult + rank_mult
                }
            end
        end
    end,
    set_sprites = function(self, card, front)
        -- Alt textures for slothful to include exotic and paperback suits if they have been unlocked
        if (self.discovered or card.bypass_discovery_center) and BUNCOMOD.funcs.exotic_in_pool() then
            card.children.center:set_sprite_pos(coordinate_from_atlas_index(73))
        end
    end
})

bunc_define_joker({ -- Xray
    name = 'Xray', position = 6,
    vars = {{bonus = 0.2}, {xmult = 1}},
    rarity = 'Common', cost = 4,
    blueprint = true, eternal = true, perishable = false,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'win_challenge' and G.GAME.challenge == 'c_xray_1' then
            self.challenge_bypass = true
            unlock_card(self)
        end
    end,
    calculate = function(self, card, context)
        if context.emplaced_card and context.emplaced_card.facing == 'back' and not context.blueprint then
            card.ability.extra.xmult = card.ability.extra.xmult + card.ability.extra.bonus
            return {
                message = localize('k_upgrade_ex'),
                instant = true
            }
        end

        if context.joker_main then
            if card.ability.extra.xmult ~= 1 then
                return {
                    xmult = card.ability.extra.xmult,
                }
            end
        end
    end
})

bunc_define_joker({ -- Dread
    name = 'Dread', position = 7,
    vars = {{levels = 2}, {trash_list = {}}, {level_up_list = {}}, {unlock = 10}},
    locked_vars = function(self, info_queue, card)
        return {vars = {self.config.extra.unlock}}
    end,
    rarity = 'Rare', cost = 8,
    blueprint = false, eternal = true, perishable = true,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'round_deck_size' and args.round_deck_size_diff <= -self.config.extra.unlock then
            unlock_card(self)
        end
    end,
    calculate = function(self, card, context)
        if not context.blueprint then
            if context.full_hand and not context.other_card then
                card.ability.extra.trash_list = {}
                for k, v in ipairs(context.full_hand) do
                    table.insert(card.ability.extra.trash_list, v)
                end
            end

            if (context.after or context.first_hand_drawn) and G.GAME.current_round.hands_left <= 1 then -- For shaking the card when there's one hand left
                event({func = function ()
                    local eval = function() return G.GAME.current_round.hands_left == nil or G.GAME.current_round.hands_left ~= 0 end
                    juice_card_until(card, eval, true)
                return true end})
            end

            if context.after and G.GAME.current_round.hands_left <= 0 and context.scoring_name then
                return {
                    message = localize('k_level_up_ex'),
                    colour = G.C.RED,
                    func = function()
                        update_hand_text({sound = 'button', volume = 0.7, pitch = 0.8, delay = 0.3}, {handname=localize(context.scoring_name, 'poker_hands'),chips = G.GAME.hands[context.scoring_name].chips, mult = G.GAME.hands[context.scoring_name].mult, level=G.GAME.hands[context.scoring_name].level})
                        level_up_hand(card, context.scoring_name, false, card.ability.extra.levels)
                        card.ability.extra.level_up_list[context.scoring_name] = (card.ability.extra.level_up_list[context.scoring_name] or 0) + card.ability.extra.levels
                        update_hand_text({sound = 'button', volume = 0.7, pitch = 1.1, delay = 0}, {mult = 0, chips = 0, handname = '', level = ''})

                        local trash_list = card.ability.extra.trash_list
                        local dissolve_time_fac = 3
                        event({
                            trigger = 'before',
                            delay = 0.7*dissolve_time_fac*1.051,
                            func = function()
                                big_juice(card)
                                for _, card_to_trash in ipairs(trash_list) do
                                    if not card_to_trash.removed then
                                        card_to_trash:start_dissolve(nil, nil, dissolve_time_fac)
                                    end
                                end
                                return true
                            end
                        })
                        
                        for _, card_to_trash in ipairs(trash_list) do
                            card_to_trash.destroyed = true
                        end
                        SMODS.calculate_context({remove_playing_cards = true, removed = trash_list})
                        card.ability.extra.trash_list = {}
                    end
                }
            end
        end
    end,
    remove = function(self, card)
        for name, level in pairs(card.ability.extra.level_up_list) do
            level_up_hand(card, name, true, level * -1)
        end
    end
})

bunc_define_joker({ -- Prehistoric
    name = 'Prehistoric', position = 8,
    vars = {{mult = 16}, {card_list = { }}},
    rarity = 'Uncommon', cost = 5,
    blueprint = true, eternal = true, perishable = true,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'hand_contents' then
            local eval = evaluate_poker_hand(args.cards)
            if next(eval['Flush Five']) then
                unlock_card(self)
            end
        end
    end,
    calculate = function(self, card, context)
        if context.individual and context.cardarea == G.play then
            for _, v in ipairs(card.ability.extra.card_list) do
                if (aij_ids_op(context.other_card, '==', v.rank))
                and (v.has_any_suit or context.other_card:is_suit(v.suit)) then
                    return {
                        mult = card.ability.extra.mult
                    }
                end
            end

            if not context.blueprint then
                if not (SMODS.has_no_suit(context.other_card) or SMODS.has_no_rank(context.other_card)) then
                    table.insert(card.ability.extra.card_list, {
                        rank = context.other_card:get_id(),
                        suit = context.other_card.base.suit,
                        has_any_suit = SMODS.has_any_suit(context.other_card),
                        ID = context.other_card.unique_val
                    }) -- Add the card to the list
                end
            end

        end

        if context.end_of_round and not context.other_card then -- Clear the list if end of round
            card.ability.extra.card_list = {}
        end
    end
})

bunc_define_joker({ -- Linocut
    name = 'Linocut', position = 9,
    rarity = 'Uncommon', cost = 4,
    blueprint = false, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if context.after and context.scoring_hand and #context.scoring_hand == 2 and not context.blueprint then
            if context.poker_hands and next(context.poker_hands['Pair']) then
                event({trigger = 'after', delay = 0.15, func = function() context.scoring_hand[1]:flip(); play_sound('card1', 1); context.scoring_hand[1]:juice_up(0.3, 0.3); return true end })
                event({trigger = 'after', delay = 0.1,  func = function() context.scoring_hand[1]:change_suit(context.scoring_hand[2].config.card.suit); return true end })
                event({trigger = 'after', delay = 0.15, func = function() context.scoring_hand[1]:flip(); play_sound('tarot2', 1, 0.6); big_juice(card); context.scoring_hand[1]:juice_up(0.3, 0.3); return true end })
                return {
                    message = G.localization.misc.dictionary["bunc_copied"],
                    colour = G.C.RED
                }
            end
        end
    end
})

bunc_define_joker({ -- Ghost Print
    name = 'Ghost Print', position = 10,
    vars = {{last_hand = 'Nothing'}},
    custom_vars = function(self, info_queue, card)
        local vars
        if card.ability.extra.last_hand == 'Nothing' then
            vars = {G.GAME.last_hand_played or G.localization.misc.dictionary.bunc_nothing}
        else
            vars = {G.localization.misc['poker_hands'][card.ability.extra.last_hand]}
        end
        return {vars = vars}
    end,
    rarity = 'Uncommon', cost = 6,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if context.joker_main then
            if card.ability.extra.last_hand ~= 'Nothing' then
                return {
                    chips = G.GAME.hands[card.ability.extra.last_hand].chips,
                    mult = G.GAME.hands[card.ability.extra.last_hand].mult,
                }
            end
        end

        if context.after and not context.blueprint then
            card.ability.extra.last_hand = G.GAME.last_hand_played
        end
    end,
    add = function(self, card, from_debuff)
        if not from_debuff then
            card.ability.extra.last_hand = G.GAME.last_hand_played or "Nothing"
        end
    end
})

bunc_define_joker({ -- Loan Shark
    name = 'Loan Shark', position = 11,
    vars = {{dollars = 50}, {cost = -100}},
    custom_vars = function(self, info_queue, card)
        local vars = {card.ability.extra.dollars, card.ability.extra.cost}
        if card.area and card.area.config.collection then
            return {key = self.key..'_full', vars = vars}
        else
            return {vars = vars}
        end
    end,
    rarity = 'Uncommon', cost = 3,
    blueprint = false, eternal = true, perishable = true,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'round_spend_money' and to_number(args.round_spend_money) >= 100 then
            unlock_card(self)
        end
    end,
    add = function(self, card, from_debuff)
        if not from_debuff then
            ease_dollars(card.ability.extra.dollars)
        end
        card:set_cost()
    end
})

bunc_define_joker({ -- Basement
    name = 'Basement', position = 12,
    rarity = 'Rare', cost = 8,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if context.end_of_round and G.GAME.blind.boss and not context.other_card then
            if #G.consumeables.cards + G.GAME.consumeable_buffer < G.consumeables.config.card_limit then
                G.GAME.consumeable_buffer = G.GAME.consumeable_buffer + 1
                G.E_MANAGER:add_event(Event({
                    func = function() 
                        local spectral = create_card('Spectral', G.consumeables, nil, nil, nil, nil, nil)
                        spectral:add_to_deck()
                        G.consumeables:emplace(spectral)
                        G.GAME.consumeable_buffer = 0
                        return true
                    end
                }))
                return {
                    message = localize('k_plus_spectral'),
                    colour = G.C.SECONDARY_SET.Spectral
                }
            end
        end
    end
})

bunc_define_joker({ -- Shepherd
    name = 'Shepherd', position = 13,
    vars = {{bonus = 6}, {chips = 0}},
    rarity = 'Common', cost = 5,
    blueprint = true, eternal = true, perishable = false,
    unlocked = true,
    calculate = function(self, card, context)
        if context.before and context.poker_hands ~= nil and next(context.poker_hands['Pair']) and not context.blueprint then
            card.ability.extra.chips = card.ability.extra.chips + card.ability.extra.bonus

            return {
                message = '+'..tostring(card.ability.extra.chips)..' '..G.localization.misc.dictionary["bunc_chips"],
                colour = G.C.BLUE
            }
        end

        if context.joker_main then
            if card.ability.extra.chips ~= 0 then
                return {
                    chips = card.ability.extra.chips
                }
            end
        end
    end
})

bunc_define_joker({ -- Joker Knight
    name = 'Knight', position = 14,
    vars = {{bonus = 6}, {mult = 0}},
    rarity = 'Uncommon', cost = 6,
    blueprint = true, eternal = true, perishable = false,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'defeat_blind' and args.blind.name == 'Amber Acorn' then
            unlock_card(self)
        end
    end,
    calculate = function(self, card, context)
        if context.setting_blind and not card.getting_sliced and not context.blueprint then
            card.ability.extra.mult = card.ability.extra.mult + card.ability.extra.bonus

            event({ trigger = 'after', delay = 0.2, func = function()
                event({ func = function() G.jokers:shuffle('aajk'); play_sound('cardSlide1', 0.85);return true end })
                delay(0.15)
                event({ func = function() G.jokers:shuffle('aajk'); play_sound('cardSlide1', 1.15);return true end })
                delay(0.15)
                event({ func = function() G.jokers:shuffle('aajk'); play_sound('cardSlide1', 1);return true end })
                delay(0.5)
                return true 
            end })

            return {
                message = '+'..tostring(card.ability.extra.mult)..' '..localize('k_mult'),
                colour = G.C.RED
            }
        end

        if context.break_positions and not context.blueprint then
            if card.ability.extra.mult ~= 0 then
                card.ability.extra.mult = 0
                return {
                    message = localize('k_reset')
                }
            end
        end

        if context.joker_main then
            if card.ability.extra.mult ~= 0 then
                return {
                    mult = card.ability.extra.mult
                }
            end
        end
    end,
    set_ability = function(self, card, initial, delay_sprites)
        if self.discovered or card.bypass_discovery_center then
            card.T.h = card.T.w
        end
    end,
    set_sprites = function(self, card, front)
        if self.discovered or card.bypass_discovery_center then
            card.children.center.scale.y = card.children.center.scale.x
        end
    end,
    load = function(self, card, card_table, other_card)
        return self.set_ability(self, card)
    end
})

bunc_define_joker({ -- Joker Man & Jester Boy Trading Card No. 54 (JMJB)
    name = 'JMJB', position = 15,
    vars = {{unlock = 50}},
    locked_vars = function(self, info_queue, card)
        return {vars = {self.config.extra.unlock, G.PROFILES[G.SETTINGS.profile].booster_packs_opened or 0}}
    end,
    rarity = 'Rare', cost = 5,
    blueprint = false, eternal = true, perishable = true,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'open_pack' and args.packs_total >= self.config.extra.unlock then
            unlock_card(self)
        end
    end,
    calculate = function(self, card, context)
        if context.open_booster and context.card.ability.name then
            if (context.open_booster and context.card.ability.name == 'Standard Pack' or
            context.open_booster and context.card.ability.name == 'Jumbo Standard Pack' or
            context.open_booster and context.card.ability.name == 'Mega Standard Pack') then
                event({
                    trigger = 'after',
                    delay = 0,
                    blockable = false,
                    blocking = false,
                    func = function()
                        if G.pack_cards and G.pack_cards.cards and G.pack_cards.cards[1] and G.pack_cards.VT.y < G.ROOM.T.h then

                            for _, v in ipairs(G.pack_cards.cards) do
                                if v.config.center == G.P_CENTERS.c_base then
                                    v:set_ability(G.P_CENTER_POOLS.Enhanced[math.random(#G.P_CENTER_POOLS.Enhanced)])
                                end
                            end

                            return true
                        end
                    end
                })
            end
        end
    end
})

bunc_define_joker({ -- Dogs Playing Poker
    name = 'Dogs Playing Poker', position = 16,
    vars = {{xmult = 2.5}},
    rarity = 'Uncommon', cost = 5,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if context.joker_main then

            local condition = true

            if context.scoring_hand then
                for i = 1, #context.scoring_hand do
                    if not (
                        context.scoring_hand[i]:get_id() == 2 or 
                        context.scoring_hand[i]:get_id() == 3 or
                        context.scoring_hand[i]:get_id() == 4 or
                        context.scoring_hand[i]:get_id() == 5
                    ) or SMODS.has_no_rank(context.scoring_hand[i]) then
                        condition = false
                    end
                end
            end

            if condition then
                return {
                    xmult = card.ability.extra.xmult,
                }
            end
        end
    end
})

bunc_define_joker({ -- Righthook
    name = 'Righthook', position = 17,
    vars = {{unlock = 5}},
    locked_vars = function(self, info_queue, card)
        return {vars = {self.config.extra.unlock}}
    end,
    rarity = 'Rare', cost = 8,
    blueprint = true, eternal = true, perishable = true,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'repetition' and args.repetition_amount >= self.config.extra.unlock then
            unlock_card(self)
        end
    end,
    calculate = function(self, card, context)
        if context.repetition and context.cardarea == G.play and context.scoring_hand and context.other_card == context.scoring_hand[#context.scoring_hand] then

            local repetitions = G.GAME.cry_panop_juggle or G.GAME.current_round.hands_left -- For cryptid compat

            return {
                message = localize('k_again_ex'),
                repetitions = repetitions
            }
        end
    end
})

bunc_define_joker({ -- Fiendish
    name = 'Fiendish', position = 18,
    vars = {{odds = 3}},
    custom_vars = function(self, info_queue, card)
        vars = {SMODS.get_probability_vars(card, 1, card.ability.extra.odds, "bunc_fiendish")}
        return {vars = vars}
    end,
    rarity = 'Uncommon', cost = 5,
    blueprint = false, eternal = true, perishable = true,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'win_challenge' and G.GAME.challenge == 'c_double_nothing_1' then
            self.challenge_bypass = true
            unlock_card(self)
        end
    end,
    calculate = function(self, card, context)
        if context.bunc_pre_money_change and context.sign == 1 then
            if SMODS.pseudorandom_probability(card, 'fiendish'..G.SEED, 1, card.ability.extra.odds, 'bunc_fiendish') then
                local new_mod = to_big(1)
                return {
                    bunc_new_dollars_mod = new_mod,
                    message = "$" .. to_number(new_mod),
                    colour = G.C.RED
                }
            else
                local new_mod = to_big(context.mod) * to_big(2)
                return {
                    bunc_new_dollars_mod = new_mod,
                    message = "$" .. to_number(new_mod),
                    colour = G.C.ORANGE
                }
            end
        end
    end
})

bunc_define_joker({ -- Carnival
    name = 'Carnival', position = 19,
    vars = {{ante = -huge_number}},
    custom_vars = function (self, info_queue, card)
        local active = (G.GAME and G.GAME.round_resets and (G.GAME.round_resets.ante > card.ability.extra.ante)) or false
        local main_end = {
            {n=G.UIT.C, config={align = "bm", minh = 0.4}, nodes={
                {n=G.UIT.C, config={ref_table = self, align = "m", colour = active and G.C.GREEN or G.C.RED, r = 0.05, padding = 0.06}, nodes={
                    {n=G.UIT.T, config={text = ' '..localize(active and 'k_active' or 'bunc_inactive')..' ',colour = G.C.UI.TEXT_LIGHT, scale = 0.32*0.9}},
                }}
            }}
        }
        return {main_end = main_end}
    end,
    rarity = 'Rare', cost = 10,
    blueprint = false, eternal = true, perishable = true,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'ante_down' and args.ante == 0 then
            unlock_card(self)
        end
    end,
    calculate = function(self, card, context)
        if context.end_of_round and G.GAME.blind.boss and not context.other_card and not context.blueprint then
            if G.GAME.round_resets.ante > card.ability.extra.ante then
                local destructable_jokers = {}
                for i = 1, #G.jokers.cards do
                    if G.jokers.cards[i] ~= card and not G.jokers.cards[i].ability.eternal and not G.jokers.cards[i].getting_sliced then destructable_jokers[#destructable_jokers+1] = G.jokers.cards[i] end
                end
                local joker_to_destroy = #destructable_jokers > 0 and pseudorandom_element(destructable_jokers, pseudoseed('carnival')) or nil

                if joker_to_destroy and not card.getting_sliced then
                    joker_to_destroy.getting_sliced = true
                    card.ability.extra.ante = G.GAME.round_resets.ante
                    ease_ante(-1)
                    G.E_MANAGER:add_event(Event({
                        func = function() 
                            card:juice_up(0.8, 0.8)
                            joker_to_destroy:start_dissolve({G.C.BLACK}, nil, 1.6)
                            play_sound('slice1', 0.96+math.random()*0.08)
                            return true
                        end
                    }))
                    return {
                        message = G.localization.misc.dictionary["bunc_loop"],
                        colour = G.C.BLACK,
                    }
                end
            end
        end
    end
})

bunc_define_joker({ -- Sledgehammer
    name = 'Sledgehammer', position = 20,
    vars = {{plus_xmult = 1}, {div_chance_denom = 4}},
    rarity = 'Uncommon', cost = 5,
    blueprint = false, eternal = true, perishable = true,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'hand_contents' then
            local tally = 0
            for j = 1, #args.cards do
                if args.cards[j].config.center == G.P_CENTERS.m_glass then
                    tally = tally + 1
                end
            end
            if tally >= 5 then
                unlock_card(self)
            end
        end
    end,
    custom_in_pool = function()
        local condition = false
        if G.playing_cards then
            for k, v in pairs(G.playing_cards) do
                if v.config.center == G.P_CENTERS.m_glass then condition = true break end
            end
        end
        return condition
    end,
    add = function(self, card)
        G.P_CENTERS.m_glass.config.Xmult = G.P_CENTERS.m_glass.config.Xmult + card.ability.extra.plus_xmult
        for _, deck_card in pairs(G.playing_cards) do
            if deck_card.config.center == G.P_CENTERS.m_glass then
                deck_card.ability.Xmult = deck_card.ability.Xmult + card.ability.extra.plus_xmult
                deck_card.ability.x_mult = deck_card.ability.x_mult + card.ability.extra.plus_xmult
            end
        end
        if #SMODS.find_card('j_bunc_sledgehammer') == 0 then
            G.P_CENTERS.m_glass.config.extra = G.P_CENTERS.m_glass.config.extra / self.config.extra.div_chance_denom

            for _, deck_card in pairs(G.playing_cards) do
                if deck_card.config.center == G.P_CENTERS.m_glass then
                    deck_card.ability.extra = deck_card.ability.extra / self.config.extra.div_chance_denom
                end
            end
        end
    end,
    remove = function(self, card)
        G.P_CENTERS.m_glass.config.Xmult = G.P_CENTERS.m_glass.config.Xmult - card.ability.extra.plus_xmult
        for _, deck_card in pairs(G.playing_cards) do
            if deck_card.config.center == G.P_CENTERS.m_glass then
                deck_card.ability.Xmult = deck_card.ability.Xmult - card.ability.extra.plus_xmult
                deck_card.ability.x_mult = deck_card.ability.x_mult - card.ability.extra.plus_xmult
            end
        end
        if #SMODS.find_card('j_bunc_sledgehammer') == 0 then
            G.P_CENTERS.m_glass.config.extra = G.P_CENTERS.m_glass.config.extra * self.config.extra.div_chance_denom

            for _, deck_card in pairs(G.playing_cards) do
                if deck_card.config.center == G.P_CENTERS.m_glass then
                    deck_card.ability.extra = deck_card.ability.extra * self.config.extra.div_chance_denom
                end
            end
        end
    end
})

bunc_define_joker({ -- Doorhanger
    name = 'Doorhanger', position = 21,
    rarity = 'Rare', cost = 10,
    blueprint = false, eternal = true, perishable = true,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'win_custom' and G.GAME.max_common_jokers == 0 then
            unlock_card(self)
        end
    end,
    set_ability = function(self, card, initial, delay_sprites)
        if self.discovered or card.bypass_discovery_center then
            card.T.w = card.T.w / 1.44
        end
    end,
    set_sprites = function(self, card, front)
        if self.discovered or card.bypass_discovery_center then
            card.children.center.scale.x = card.children.center.scale.x / 1.44
        end
    end,
    load = function(self, card, card_table, other_card)
        return self.set_ability(self, card)
    end
})

bunc_define_joker({ -- Fingerprints
    name = 'Fingerprints', position = 22,
    vars = {{bonus = 50}, {scoring_card_set = {}}},
    rarity = 'Uncommon', cost = 8,
    blueprint = false, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if context.after and context.scoring_name ~= nil and context.scoring_hand and not context.blueprint then
            if ((SMODS.calculate_round_score() + G.GAME.chips) - G.GAME.blind.chips) >= to_big(0) then
                card.ability.extra.scoring_card_set = {}
                for i = 1, #context.scoring_hand do
                    local other_card = context.scoring_hand[i]
                    if not other_card.debuff then
                        event({func = function()
                            big_juice(other_card)
                            return true
                        end})
                        
                        -- Save upgraded cards to actually upgrade after end_round() triggers
                        card.ability.extra.scoring_card_set[other_card.unique_val] = true
                    end
                end
                return {
                    message = localize('k_upgrade_ex'),
                    colour = G.C.CHIPS
                }
            end
        end

        if context.end_of_round and context.cardarea == G.jokers and not context.blueprint then
            if card.ability.extra.scoring_card_set then
                for _, v in ipairs(G.playing_cards) do
                    if card.ability.extra.scoring_card_set[v.unique_val] then
                        v.ability = v.ability or {}
                        v.ability.temporary_extra_chips = (v.ability.temporary_extra_chips or 0) + card.ability.extra.bonus
                    end
                end
                -- not needed, but good style to fail fast
                card.ability.extra.scoring_card_set = nil
            end
        end
    end
})

bunc_define_joker({ -- Zero Shapiro
    name = 'Zero Shapiro', position = 23,
    vars = {{odds = 8}},
    custom_vars = function(self, info_queue, card)
        info_queue[#info_queue+1] = {set = 'Tag', key = 'tag_d_six'}

        local vars = {SMODS.get_probability_vars(card, 1, card.ability.extra.odds, "bunc_zero_shapiro")}
        return {vars = vars}
    end,
    rarity = 'Uncommon', cost = 4,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if context.individual and context.cardarea == G.play then
            if context.other_card:get_id() == 11 or context.other_card:get_id() == 12 or context.other_card:get_id() == 13 or SMODS.has_no_rank(context.other_card) then
                if SMODS.pseudorandom_probability(card, pseudorandom('zero_shapiro'..G.SEED), 1, card.ability.extra.odds, 'bunc_zero_shapiro') then
                    return {
                        message = '+'..localize{type = 'name_text', key = 'tag_d_six', set = 'Tag'},
                        blocking = false,
                        colour = G.C.GREEN,
                        func = function()
                            event({trigger="before", delay = 0.7 * 1.25, func = function()
                                add_tag(Tag('tag_d_six'))
                                return true
                            end})
                        end
                    }
                end
            end
        end
    end
})

bunc_define_joker({ -- Nil Bill
    name = 'Nil Bill', position = 24,
    vars = {{bonus = 2}},
    rarity = 'Uncommon', cost = 4,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if context.remove_playing_cards then
            return {
                dollars = card.ability.extra.bonus * #context.removed
            }
        end
    end
})

bunc_define_joker({ -- Bierdeckel
    name = 'Bierdeckel', position = 25,
    vars = {{bonus = 10}},
    rarity = 'Uncommon', cost = 4,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if (context.after or context.discard and context.other_card == context.full_hand[1]) then
            local full_hand_set = {}
            if context.discard then
                for _, c in ipairs(context.full_hand) do
                    full_hand_set[c] = true
                end
            end
            for _, c in ipairs(G.hand.cards) do
                if not full_hand_set[c] and not c.highlighted then
                    c.ability = c.ability or {}
                    c.ability.temporary_extra_chips = (c.ability.temporary_extra_chips or 0) + card.ability.extra.bonus
                end
            end

            -- maybe juice all held cards, that'd be fun
            return {
                message = localize('k_upgrade_ex'),
                colour = G.C.CHIPS
            }
        end
    end,
    set_ability = function(self, card, initial, delay_sprites)
        if self.discovered or card.bypass_discovery_center then
            card.T.h = card.T.w
        end
    end,
    set_sprites = function(self, card, front)
        if self.discovered or card.bypass_discovery_center then
            card.children.center.scale.y = card.children.center.scale.x
        end
    end,
    load = function(self, card, card_table, other_card)
        return self.set_ability(self, card)
    end
})

local bunc_registration_plate_refresh = function (card)
    -- TODO: Make it so a card cannot be randomly chosen twice
    local card_list = {}
    for i = 1, 5 do
        local index = math.random(#G.deck.cards)
        table.insert(card_list, G.deck.cards[index])
    end

    card.ability.extra.combination = {}
    for i = 1, 5 do
        table.insert(card.ability.extra.combination, card_list[i].base.value)
    end

    card.ability.extra.ranks = {}
    for i = 1, 5 do
        table.insert(card.ability.extra.ranks, card_list[i]:get_id())
    end
end
bunc_define_joker({ -- Registration Plate
    name = 'Registration Plate', position = 26,
    vars = {{combination = {"2", "3", "4", "5", "6"}}, {ranks = {}}},
    rarity = 'Rare', cost = 8,
    blueprint = false, eternal = true, perishable = true,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'win_challenge' and G.GAME.challenge == 'c_city_1' then
            self.challenge_bypass = true
            unlock_card(self)
        end
    end,
    custom_vars = function(self, info_queue, card)
        local vars = {}
        for i = 1, #card.ability.extra.combination do
            table.insert(vars, localize(card.ability.extra.combination[i], 'ranks'))
        end
        return {vars = vars}
    end,
    add = function(self, card, from_debuff)
        if from_debuff then
            return
        end

        bunc_registration_plate_refresh(card)
    end,
    calculate = function(self, card, context)
        if context.end_of_round and #G.deck.cards ~= 0 then

            bunc_registration_plate_refresh(card)
        end
    end
})

local bunc_slothful_sprite_change = function(card)
    if BUNCOMOD.funcs.exotic_in_pool() then
        if next(SMODS.find_mod("paperback")) and (SMODS.Suits.paperback_Crowns:in_pool() or SMODS.Suits.paperback_Stars:in_pool()) then
            card.children.center:set_sprite_pos(coordinate_from_atlas_index(76))
        else
            card.children.center:set_sprite_pos(coordinate_from_atlas_index(74))
        end
    else
        if next(SMODS.find_mod("paperback")) and (SMODS.Suits.paperback_Crowns:in_pool() or SMODS.Suits.paperback_Stars:in_pool()) then
            card.children.center:set_sprite_pos(coordinate_from_atlas_index(75))
        end
    end
end
bunc_define_joker({ -- Slothful
    name = 'Slothful', position = 27,
    vars = {{mult = 9}},
    rarity = 'Uncommon', cost = 5,
    blueprint = true, eternal = true, perishable = true,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'hand_contents' then
            local tally = 0
            for j = 1, #args.cards do
                if args.cards[j].config.center == G.P_CENTERS.m_wild then
                    tally = tally + 1
                end
            end
            if tally >= 5 then
                unlock_card(self)
            end
        end
    end,
    custom_in_pool = function()
        if G.playing_cards then
            for k, v in pairs(G.playing_cards) do
                if v.config.center == G.P_CENTERS.m_wild then 
                    return true
                end
            end
        end
        return false
    end,
    calculate = function(self, card, context)
        if context.individual and context.cardarea == G.play then
            if context.other_card.config.center == G.P_CENTERS.m_wild then
                if not context.blueprint then
                    event({
                        blocking = false,
                        func = function()
                            bunc_slothful_sprite_change(card)
                            return true
                        end
                    })
                end
                return {
                    mult = card.ability.extra.mult,
                    card = card
                }
            end
        end
    end,
    set_sprites = function(self, card, front)
        -- Alt textures for slothful to include exotic and paperback suits if they have been unlocked
        if self.discovered or card.bypass_discovery_center then
            bunc_slothful_sprite_change(card)
        end
    end
})

bunc_define_joker({ -- Neon
    name = 'Neon', position = 28,
    custom_vars = function(self, info_queue, card)
        info_queue[#info_queue+1] = G.P_CENTERS.e_bunc_fluorescent
    end,
    rarity = 'Uncommon', cost = 5,
    blueprint = false, eternal = true, perishable = true,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'hand_contents' then
            local tally = 0
            for j = 1, #args.cards do
                if args.cards[j].debuff then
                    tally = tally + 1
                end
            end
            if tally >= 5 then
                unlock_card(self)
            end
        end
    end,
    calculate = function(self, card, context)
        if context.enhance_card and not context.blueprint then
            if context.enhanced_card.area == G.hand then
                if context.enhanced_card:get_edition() == nil then
                    context.enhanced_card:set_edition({bunc_fluorescent = true})
                    event({func = function() big_juice(card) return true end})
                end
            end
        end
    end

})

bunc_define_joker({ -- Gameplan
    name = 'Gameplan', position = 29,
    vars = {{mult = 20}},
    rarity = 'Uncommon', cost = 5,
    blueprint = true, eternal = true, perishable = true,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'defeat_blind' and args.blind.name == 'Verdant Leaf' then
            unlock_card(self)
        end
    end,
    update = function(self, card)
        if G.jokers then
            for i = 1, #G.jokers.cards do
                G.GAME.blind:debuff_card(G.jokers.cards[i])
            end
        end
    end,
    remove = function(self, card)
        if G.jokers then
            for i = 1, #G.jokers.cards do
                G.GAME.blind:debuff_card(G.jokers.cards[i])
            end
        end
    end,
    calculate = function(self, card, context)
        if context.other_joker then
            local mult = 0

            local my_pos = nil
            for i = 1, #G.jokers.cards do
                if G.jokers.cards[i] == card then my_pos = i; break end
            end
            if context.other_joker == G.jokers.cards[my_pos - 1] then mult = card.ability.extra.mult end
            if context.other_joker == G.jokers.cards[my_pos + 1] then mult = card.ability.extra.mult end

            if mult ~= 0 then
                return {
                    mult = mult,
                    card = context.other_joker
                }
            end
        end
    end
})

bunc_define_joker({ -- Conquest
    name = 'Conquest', position = 30,
    vars = {{chips = 200}, {joker = 0}},
    rarity = 'Uncommon', cost = 5,
    blueprint = true, eternal = true, perishable = true,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'defeat_blind' and args.blind.name == 'Crimson Heart' then
            unlock_card(self)
        end
    end,
    update = function(self, card)
        if G.jokers then
            for i = 1, #G.jokers.cards do
                G.GAME.blind:debuff_card(G.jokers.cards[i])
            end
        end
    end,
    remove = function(self, card)
        if G.jokers then
            for i = 1, #G.jokers.cards do
                if G.jokers.cards[i].ability.bunc_conquest_chosen == card.unique_val then G.jokers.cards[i].ability.bunc_conquest_chosen = nil end
                G.GAME.blind:debuff_card(G.jokers.cards[i])
            end
        end
    end,
    calculate = function(self, card, context)
        if context.setting_blind and not context.blueprint then
            local my_pos = nil
            for i = 1, #G.jokers.cards do
                if G.jokers.cards[i] == card then my_pos = i end
                if G.jokers.cards[i].ability.bunc_conquest_chosen == card.unique_val then G.jokers.cards[i].ability.bunc_conquest_chosen = nil end
            end

            if #G.jokers.cards > 1 then
                event({func = function()
                    local random_index = math.random(#G.jokers.cards - 1)
                    if random_index >= my_pos then
                        random_index = random_index + 1
                    end
                    G.jokers.cards[random_index].ability.bunc_conquest_chosen = card.unique_val
                    G.GAME.blind:debuff_card(G.jokers.cards[random_index])
                    big_juice(G.jokers.cards[random_index])
                    return true
                end})

                -- Using forced_message since SMOD will stil display message if debuffed
                event({delay = 0.7 * 1.25, func = function()
                    if not card.debuffed then
                        card_eval_status_text(
                            card,
                            'extra',
                            nil, percent, nil,
                            {message = G.localization.misc.dictionary["bunc_debuffed"], colour = G.C.RED, instant = true}
                        )
                    end
                    return true
                end})
            end
        end
        if context.joker_main then
            return {
                chips = card.ability.extra.chips
            }
        end
    end,
})

bunc_define_joker({ -- Hierarchy of Needs
    name = 'Hierarchy of Needs', position = 31,
    vars = {{bonus = 5}, {mult = 20}},
    rarity = 'Common', cost = 5,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true,
    update = function(self, card)
        if G.playing_cards then
            local required_ranks = {'2', '3', '4', '5', '6', '7', '8', '9', '10', 'Jack', 'Queen', 'King', 'Ace'}
            local set_count = 0

            for _, suit_data in pairs(SMODS.Suits) do
                local suit = tostring(suit_data.key)
                local rank_count = {}

                for _, rank in ipairs(required_ranks) do
                    rank_count[rank] = 0
                end

                for _, deck_card in ipairs(G.playing_cards) do
                    local rank

                    if deck_card.config.center ~= G.P_CENTERS.m_stone and deck_card.base.suit == suit then
                        rank = deck_card.base.value
                    end

                    if rank and rank_count[rank] then
                        rank_count[rank] = rank_count[rank] + 1

                        local complete_set = true
                        for _, req_rank in ipairs(required_ranks) do
                            if rank_count[req_rank] == 0 then
                                complete_set = false
                                break
                            end
                        end

                        if complete_set then
                            set_count = set_count + 1
                            for _, req_rank in ipairs(required_ranks) do
                                rank_count[req_rank] = rank_count[req_rank] - 1
                            end
                        end
                    end
                end
            end
            card.ability.extra.mult = card.ability.extra.bonus * set_count
        else
            card.ability.extra.mult = card.ability.extra.bonus * 4
        end
    end,
    calculate = function(self, card, context)
        if context.joker_main then
            if card.ability.extra.mult ~= 0 then
                return {
                    mult = card.ability.extra.mult
                }
            end
        end
    end
})

bunc_define_joker({ -- Dwarven
    name = 'Dwarven', position = 32,
    custom_vars = function(self, info_queue, card)
        info_queue[#info_queue+1] = G.P_CENTERS.m_stone
        info_queue[#info_queue+1] = G.P_CENTERS.m_steel
        info_queue[#info_queue+1] = G.P_CENTERS.m_gold
        return {}
    end,
    rarity = 'Uncommon', cost = 8,
    blueprint = false, eternal = true, perishable = true,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'hand_contents' then
            local stone, steel, gold = false, false, false
            for j = 1, #args.cards do
                if args.cards[j].config.center == G.P_CENTERS.m_stone then
                    stone = true
                end
                if args.cards[j].config.center == G.P_CENTERS.m_steel then
                    steel = true
                end
                if args.cards[j].config.center == G.P_CENTERS.m_gold then
                    gold = true
                end
            end
            if stone and steel and gold then
                unlock_card(self)
            end
        end
    end,
    custom_in_pool = function()
        local condition = false
        if G.playing_cards then
            for k, v in pairs(G.playing_cards) do
                if v.config.center == G.P_CENTERS.m_stone then condition = true break end
            end
        end
        return condition
    end,
    add = function(self, card)
        for _, deck_card in pairs(G.playing_cards) do
            if deck_card.config.center == G.P_CENTERS.m_stone then
                deck_card.ability.h_x_mult = (deck_card.ability.h_x_mult or 0) + G.P_CENTERS.m_steel.config.h_x_mult
                deck_card.ability.h_dollars = (deck_card.ability.h_dollars or 0) + G.P_CENTERS.m_gold.config.h_dollars
            end
        end
        G.P_CENTERS.m_stone.config.h_x_mult = (G.P_CENTERS.m_stone.config.h_x_mult or 0) + G.P_CENTERS.m_steel.config.h_x_mult
        G.P_CENTERS.m_stone.config.h_dollars = (G.P_CENTERS.m_stone.config.h_dollars or 0) + G.P_CENTERS.m_gold.config.h_dollars
    end,
    remove = function(self, card)
        for _, deck_card in pairs(G.playing_cards) do
            if deck_card.config.center == G.P_CENTERS.m_stone then
                deck_card.ability.h_x_mult = deck_card.ability.h_x_mult - G.P_CENTERS.m_steel.config.h_x_mult
                deck_card.ability.h_dollars = deck_card.ability.h_dollars - G.P_CENTERS.m_gold.config.h_dollars
            end
        end
        G.P_CENTERS.m_stone.config.h_x_mult = G.P_CENTERS.m_stone.config.h_x_mult - G.P_CENTERS.m_steel.config.h_x_mult
        G.P_CENTERS.m_stone.config.h_dollars = G.P_CENTERS.m_stone.config.h_dollars - G.P_CENTERS.m_gold.config.h_dollars
    end
})

bunc_define_joker({ -- Aristocrat
    name = 'Aristocrat', position = 33,
    rarity = 'Uncommon', cost = 6,
    blueprint = true, eternal = true, perishable = true,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'win_custom' and G.GAME.booster_packs_opened == 0 then
            unlock_card(self)
        end
    end,
    calculate = function(self, card, context)
        if context.open_booster and context.card.ability.name and not G.GAME.rerolled_pack then
            event({
                trigger = 'after',
                delay = 0,
                blockable = false,
                blocking = false,
                func = function()
                    if G.pack_cards and G.pack_cards.cards and G.pack_cards.cards[1] and (G.pack_cards.VT.y < G.ROOM.T.h) then
                        G.GAME.pack_choices = G.GAME.pack_choices + 1
                        if G.GAME.pack_choices > #G.pack_cards.cards then
                            G.GAME.pack_choices = #G.pack_cards.cards
                        end
                        return true
                    end
                end
            })
        end
    end
})

bunc_define_joker({ -- Metallurgist
    name = 'Metallurgist', position = 34,
    vars = {{mult = 10}},
    custom_vars = function(self, info_queue, card)
        info_queue[#info_queue+1] = G.P_CENTERS.m_gold
        return {vars = {card.ability.extra.mult}}
    end,
    rarity = 'Common', cost = 6,
    blueprint = false, eternal = true, perishable = true,
    unlocked = true,
    custom_in_pool = function()
        local condition = false
        if G.playing_cards then
            for k, v in pairs(G.playing_cards) do
                if v.config.center == G.P_CENTERS.m_gold then condition = true break end
            end
        end
        return condition
    end,
    add = function(self, card)
        for _, deck_card in pairs(G.playing_cards) do
            if deck_card.config.center == G.P_CENTERS.m_gold then
                deck_card.ability.h_mult = (deck_card.ability.h_mult and (deck_card.ability.h_mult + card.ability.extra.mult) or 0)
            end
        end
        G.P_CENTERS.m_gold.config.h_mult = (G.P_CENTERS.m_gold.config.h_mult or 0) + card.ability.extra.mult
    end,
    remove = function(self, card)
        for _, deck_card in pairs(G.playing_cards) do
            if deck_card.config.center == G.P_CENTERS.m_gold then
                deck_card.ability.h_mult = deck_card.ability.h_mult - card.ability.extra.mult
            end
        end
        G.P_CENTERS.m_gold.config.h_mult = (G.P_CENTERS.m_gold.config.h_mult and (G.P_CENTERS.m_gold.config.h_mult - card.ability.extra.mult) or 0)
    end
})

bunc_define_joker({ -- Juggalo
    name = 'Juggalo', position = 35,
    vars = {{unlock = 10}},
    custom_vars = function(self, info_queue, card)
        info_queue[#info_queue+1] = G.P_CENTERS.e_foil
        info_queue[#info_queue+1] = G.P_CENTERS.e_holo
        info_queue[#info_queue+1] = G.P_CENTERS.e_polychrome
        info_queue[#info_queue+1] = G.P_CENTERS.e_bunc_glitter
        return {}
    end,
    locked_vars = function(self, info_queue, card)
        return {vars = {self.config.extra.unlock, G.PROFILES[G.SETTINGS.profile].consumables_with_edition_used or 0}}
    end,
    rarity = 'Rare', cost = 5,
    blueprint = true, eternal = true, perishable = true,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'use_consumable_with_edition' and args.used_total >= self.config.extra.unlock then
            unlock_card(self)
        end
    end,
    calculate = function(self, card, context)
        if context.setting_blind then
            if G.consumeables.cards[1] then
                local consumables_table = {}
                for i = 1, #G.consumeables.cards do
                    if G.consumeables.cards[i]:get_edition() == nil then
                        table.insert(consumables_table, G.consumeables.cards[i])
                    end
                end
                local consumable = consumables_table[math.random(#consumables_table)]
                local edition = poll_edition('standard_edition'..G.GAME.round_resets.ante, nil, true, true,
                {'e_holo', 'e_foil', 'e_polychrome', 'e_bunc_glitter'})
                if consumable then
                    event({func = function()
                        big_juice(consumable)
                        consumable:set_edition(edition, true)
                        return true
                    end})
                    return {
                        message = localize('k_upgrade_ex'),
                        colour = G.C.RED
                    }
                end
            end
        end
    end
})

bunc_define_joker({ -- Head in the Clouds
    name = 'Head in the Clouds', position = 36,
    vars = {{odds = 3}},
    custom_vars = function(self, info_queue, card)
        vars = {SMODS.get_probability_vars(card, 1, card.ability.extra.odds, "bunc_head_in_the_clouds")}
        return {vars = vars}
    end,
    rarity = 'Uncommon', cost = 6,
    blueprint = true, eternal = true, perishable = true,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'win_custom' then
            local handname, level, order = 'High Card', to_big(-1), 100
            for k, v in pairs(G.GAME.hands) do
                if v.level > level or (v.level == level and order > v.order) then
                    level = v.level
                    handname = k
                end
            end
            if handname == 'High Card' and level > to_big(0) then
                unlock_card(self)
            end
        end
    end,
    custom_in_pool = function()
        local condition = false
        if G.GAME and G.GAME.hands then
            if G.GAME.hands['High Card'].level > to_big(1) then condition = true end
        end
        return condition
    end,
    calculate = function(self, card, context)
        if context.level_up_hand and context.level_up_hand ~= self.name then
            if SMODS.pseudorandom_probability(card, 'head_in_the_clouds'..G.SEED, 1, card.ability.extra.odds, 'bunc_head_in_the_clouds') then
                event({func = function()
                    local hand = 'High Card'
                    card_eval_status_text(context.blueprint_card or card, 'extra', nil, nil, nil, {message = localize('k_upgrade_ex')})
                    update_hand_text({sound = 'button', volume = 0.7, pitch = 0.8, delay = 0.3}, {handname=localize(hand, 'poker_hands'),chips = G.GAME.hands[hand].chips, mult = G.GAME.hands[hand].mult, level=G.GAME.hands[hand].level})
                    level_up_hand(context.blueprint_card or card, self.name, nil, 1)
                    update_hand_text({sound = 'button', volume = 0.7, pitch = 1.1, delay = 0}, {mult = 0, chips = 0, handname = '', level = ''})
                    return true 
                end})
            end
        end
    end
})

bunc_define_joker({ -- Headshot
    name = 'Headshot', position = 37,
    vars = {{xmult = 3}},
    rarity = 'Uncommon', cost = 8,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if context.joker_main and context.scoring_hand then
            local face_amount = 0
            for i = 1, #context.scoring_hand do
                if context.scoring_hand[i]:is_face() then
                    face_amount = face_amount + 1
                end
            end

            if face_amount == 1 then
                return {
                    xmult = card.ability.extra.xmult,
                }
            end
        end
    end
})

function create_UIBox_bunc_trigger_finger_config()    
    local t = create_UIBox_generic_options({ contents = {
        {n=G.UIT.R, config={align = "cm", padding = 0.15, colour = G.C.CLEAR}, nodes={
            {n=G.UIT.C, config={align = "cm", padding = 0.15}, nodes={
                create_slider({label = G.localization.descriptions.Joker.j_bunc_trigger_finger.name .. " (" .. G.localization.misc.dictionary.bunc_volume .. ")", w = 5, h = 0.4, ref_table = G.SETTINGS.SOUND, ref_value = 'bunc_trigger_finger_volume', min = 0, max = 100}),
            }}
        }}
    }})
    return t
end
G.FUNCS.j_bunc_trigger_finger_settings = function(e)
	G.FUNCS.overlay_menu{
		definition = create_UIBox_bunc_trigger_finger_config(),
        config = {offset = {x=0,y=10}}
	}
end
bunc_define_joker({ -- Trigger Finger
    name = 'Trigger Finger', position = 38,
    vars = {{xmult = 4}, {odds = 10}},
    custom_vars = function(self, info_queue, card)
        local vars = {card.ability.extra.xmult, SMODS.get_probability_vars(card, 1, card.ability.extra.odds, 'bunc_trigger_finger')}
        return {vars = vars}
    end,
    rarity = 'Rare', cost = 8,
    blueprint = true, eternal = true, perishable = true,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'defeat_blind' and args.blind.name == 'Cerulean Bell' then
            unlock_card(self)
        end
    end,
    calculate = function(self, card, context)
        if context.bunc_trigger_finger_highlight_card and (G.STATE == G.STATES.SELECTING_HAND or G.STATE == G.STATES.DRAW_TO_HAND) and G.GAME.STOP_USE <= 0 then
            local cards = {}
            for i = 1, #G.hand.highlighted do
                table.insert(cards, G.hand.highlighted[i])
            end
            if #cards > 0 and SMODS.pseudorandom_probability(card, 'trigger_finger'..G.SEED, 1, card.ability.extra.odds, 'bunc_trigger_finger') then
                for i = 1, #cards do
                    if not cards[i].highlighted then
                        cards[i]:highlight()
                    end
                end
                if G.hand.highlighted then
                    G.FUNCS.play_cards_from_highlighted()
                    G.STATE = G.STATES.HAND_PLAYED
                    G.STATE_COMPLETE = true
                end
                if G.SETTINGS.SOUND.bunc_trigger_finger_volume == 0 then
                    return {
                        message = G.localization.misc.dictionary.bunc_pew,
                        colour = G.C.RED,
                        instant = true
                    }
                else
                    return {
                        message = G.localization.misc.dictionary.bunc_pew,
                        colour = G.C.RED,
                        sound = 'bunc_gunshot',
                        volume = G.SETTINGS.SOUND.bunc_trigger_finger_volume / 100,
                        instant = true
                    }
                end
            end
        end
        if context.joker_main then
            return {
                xmult = card.ability.extra.xmult,
            }
        end
    end
})

bunc_define_joker({ -- Hopscotch
    name = 'Hopscotch', position = 39,
    vars = {{discard = 1}},
    rarity = 'Common', cost = 4,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if context.before and context.poker_hands ~= nil and next(context.poker_hands['Straight']) then
            ease_discard(card.ability.extra.discard)
            return {
                message = '+'..card.ability.extra.discard..' '..localize('b_discard'),
                colour = G.C.RED
            }
        end
    end
})

bunc_define_joker({ -- Pawn
    name = 'Pawn', position = 40,
    custom_vars = function(self, info_queue, card)
        if G.playing_cards and #G.playing_cards > 0 then
            local rank = math.huge
            local display_rank = ""
            for _, deck_card in ipairs(G.playing_cards) do
                if deck_card:get_id() < rank and not SMODS.has_no_rank(deck_card) then
                    rank = deck_card:get_id()
                    display_rank = deck_card.base.value
                end
            end
            return {vars = {localize(tostring(display_rank), 'ranks')}}
        end
        return {vars = {localize('2', 'ranks')}}
    end,
    rarity = 'Common', cost = 5,
    blueprint = false, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if context.after and context.scoring_hand and not context.blueprint then
            for i = 1, #context.scoring_hand do
                local condition = false
                local other_card = context.scoring_hand[i]
                local rank = math.huge
                for _, deck_card in ipairs(G.playing_cards) do
                    if deck_card:get_id() < rank and not SMODS.has_no_rank(deck_card) then
                        rank = deck_card:get_id()
                    end
                end
                if other_card:get_id() == rank then
                    condition = true
                    event({trigger = 'after', delay = 0.15, func = function() other_card:flip(); play_sound('card1', 1); other_card:juice_up(0.3, 0.3); return true end })
                    event({
                        trigger = 'after',
                        delay = 0.1,
                        func = function()
                            local suit_data = SMODS.Suits[other_card.base.suit]
                            local suit_prefix = suit_data.card_key
                            local rank_data = SMODS.Ranks[other_card.base.value]
                            local behavior = rank_data.strength_effect or { fixed = 1, ignore = false, random = false }
                            local rank_suffix = ''
                            if behavior.ignore or not next(rank_data.next) then
                                return true
                            elseif behavior.random then
                                -- TODO doesn't respect in_pool
                                local r = pseudorandom_element(rank_data.next, pseudoseed('strength'))
                                rank_suffix = SMODS.Ranks[r].card_key
                            else
                                local ii = (behavior.fixed and rank_data.next[behavior.fixed]) and behavior.fixed or 1
                                rank_suffix = SMODS.Ranks[rank_data.next[ii]].card_key
                            end
                            other_card:set_base(G.P_CARDS[suit_prefix .. '_' .. rank_suffix])
                            return true
                        end
                    })
                    event({trigger = 'after', delay = 0.15, func = function() other_card:flip(); play_sound('tarot2', 1, 0.6); big_juice(card); other_card:juice_up(0.3, 0.3); return true end })
                end
                if condition then delay(0.7 * 1.25) end
            end
        end
    end
})

bunc_define_joker({ -- Puzzle Board
    name = 'Puzzle Board', position = 41,
    vars = {{odds = 4}},
    custom_vars = function(self, info_queue, card)

        info_queue[#info_queue+1] = G.P_CENTERS.e_foil
        info_queue[#info_queue+1] = G.P_CENTERS.e_holo
        info_queue[#info_queue+1] = G.P_CENTERS.e_polychrome
        info_queue[#info_queue+1] = G.P_CENTERS.e_bunc_glitter

        vars = {SMODS.get_probability_vars(card, 1, card.ability.extra.odds, "bunc_puzzle_board")}
        return {vars = vars}
    end,
    rarity = 'Uncommon', cost = 6,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if context.using_consumeable and context.consumeable.ability.set == 'Tarot' and #G.hand.highlighted > 0 then
            if SMODS.pseudorandom_probability(card, 'puzzle_board'..G.SEED, 1, card.ability.extra.odds, 'bunc_puzzle_board') then
                local cards = {}
                local edition = poll_edition('wheel_of_fortune', nil, true, true)

                for i = 1, #G.hand.highlighted do
                    if G.hand.highlighted[i]:get_edition() == nil then
                        table.insert(cards, G.hand.highlighted[i])
                    end
                end
                event({trigger = 'after', func = function()
                    if cards and #cards > 0 then
                        big_juice(card)
                        cards[math.random(#cards)]:set_edition(edition, true)
                    end
                return true end})
            else
                return {
                    message = localize('k_nope_ex'),
                    colour = G.C.RED,
                }
            end
        end
    end
})

bunc_define_joker({ -- Vandalism
    name = 'Vandalism', position = 42, soul = coordinate_from_atlas_index(42),
    vars = {{odds = 4}, {xmult = 2}, {card_list = {}}},
    custom_vars = function(self, info_queue, card)
        local vars = {SMODS.get_probability_vars(card, 1, card.ability.extra.odds, 'bunc_vandalism')}
        table.insert(vars, card.ability.extra.xmult)
        return {vars = vars}
    end,
    rarity = 'Rare', cost = 6,
    blueprint = true, eternal = true, perishable = true,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'play_all_flipped' then
            unlock_card(self)
        end
    end,
    calculate = function(self, card, context)
        if context.stay_flipped and context.to_area == G.hand then
            -- Does not juice while in booster packs
            if G.STATE == G.STATES.SELECTING_HAND or G.STATE == G.STATES.DRAW_TO_HAND then
                if (SMODS.pseudorandom_probability(card, 'vandalism'..G.SEED, 1, card.ability.extra.odds, 'bunc_vandalism')) then
                    big_juice(context.blueprint_card or card)
                    return {
                        stay_flipped = true
                    }
                else
                    return {
                        stay_flipped = false
                    }
                end
            end
        end
        if context.bunc_play_cards then
            card.ability.extra.card_list = {}
            for i = 1, #G.hand.highlighted do
                if G.hand.highlighted[i].facing == 'back' then
                    table.insert(card.ability.extra.card_list, G.hand.highlighted[i])
                end
            end
        end
        if context.individual and context.cardarea == G.play and context.other_card then
            local condition = false
            for i = 1, #card.ability.extra.card_list do
                local flipped_card = card.ability.extra.card_list[i]
                if context.other_card == flipped_card then
                    condition = true
                    break
                end
            end
            if condition then return {
                x_mult = card.ability.extra.xmult,
                card = card
            }
            end
        end
    end,
    set_sprites = function(self, card, front)
        if card.config.center.discovered or card.bypass_discovery_center then
            card.children.center = Sprite(card.T.x, card.T.y, card.T.w, card.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'], card.params.bypass_back or (card.playing_card and G.GAME[card.back].pos or G.P_CENTERS['b_red'].pos))
            card.children.center.states.hover = card.states.hover
            card.children.center.states.click = card.states.click
            card.children.center.states.drag = card.states.drag
            card.children.center.states.collide.can = false
            card.children.center:set_role({major = card, role_type = 'Glued', draw_major = card})

            card.children.back = Sprite(card.T.x, card.T.y, card.T.w, card.T.h, G.ASSET_ATLAS['bunc_bunco_jokers_winking'], coordinate_from_atlas_index(1))
            card.children.back.states.hover = card.states.hover
            card.children.back.states.click = card.states.click
            card.children.back.states.drag = card.states.drag
            card.children.back.states.collide.can = false
            card.children.back:set_role({major = card, role_type = 'Glued', draw_major = card})
        end
        card.draw_bypass = {floating_sprite = true}
    end,
    drawsteps = {
        {
            order = 61,
            func = function(card, layer)
                if card.config.center.key == 'j_bunc_vandalism' and (card.config.center.discovered or card.bypass_discovery_center) then
                    card.children.floating_sprite:draw_shader('dissolve', nil, nil, nil, card.children.center, 0, 0)
                    if card.edition then
                        for k, v in pairs(G.P_CENTER_POOLS.Edition) do
                            if card.edition[v.key:sub(3)] and v.shader then
                                card.children.floating_sprite:draw_shader(v.shader, nil, card.ARGS.send_to_shader, nil, card.children.center, 0, 0)
                            end
                        end
                    end
                end
            end
        }
    }
})

bunc_define_joker({ -- Protester
    name = 'Protester', position = 43,
    vars = {{chip_mult = 8}, {chips = 0}, {rank = -huge_number}},
    rarity = 'Common', cost = 4,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if context.pre_discard then
            local raised_card = nil
            for i = 1, #G.hand.highlighted do
                if not card.debuff and card.ability.extra.rank < G.hand.highlighted[i].base.nominal then
                    if not SMODS.has_no_rank(G.hand.highlighted[i]) and not G.hand.highlighted[i].debuff then
                        card.ability.extra.chips = G.hand.highlighted[i].base.nominal * card.ability.extra.chip_mult
                        card.ability.extra.rank = G.hand.highlighted[i].base.nominal
                        raised_card = G.hand.highlighted[i]
                    end
                end
            end
            if raised_card then
                return {
                    message = localize{type = 'variable', key = 'a_chips', vars = {card.ability.extra.chips}}
                }
            end
        end
        if context.joker_main then
            if card.ability.extra.chips ~= 0 then
                return {
                    chips = card.ability.extra.chips,
                }
            end
        end
        if context.end_of_round then
            if card.ability.extra.rank ~= -huge_number then
                card.ability.extra.rank = -huge_number
                card.ability.extra.chips = 0

                return {
                    message = localize('k_reset'),
                    colour = G.C.red_card
                }
            end
        end
    end
})

bunc_define_joker({ -- Doodle
    name = 'Doodle', position = 44,
    vars = {{active = true}, {unlock = 10}},
    locked_vars = function(self, info_queue, card)
        return {vars = {self.config.extra.unlock, G.PROFILES[G.SETTINGS.profile].career_stats.c_wins}}
    end,
    rarity = 'Rare', cost = 10,
    blueprint = true, eternal = true, perishable = true,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'win_custom' and (G.PROFILES[G.SETTINGS.profile].career_stats.c_wins + 1) >= self.config.extra.unlock then
            unlock_card(self)
        end
    end,
    calculate = function(self, card, context)
        if context.end_of_round then
            if not card.ability.extra.active then
                card.ability.extra.active = true
                local eval = function() return card.ability.extra.active end
                juice_card_until(card, eval, true)
            end
        end
        if context.using_consumeable and card.ability.extra.active and (context.consumeable.ability.set == 'Tarot' or context.consumeable.ability.set == 'Planet') then
            event({func = function ()
                if #G.consumeables.cards + G.GAME.consumeable_buffer < G.consumeables.config.card_limit then
                    local copy
                    card.ability.extra.active = false
                    copy = copy_card(context.consumeable)
                    copy:add_to_deck()
                    G.consumeables:emplace(copy)
                end
                return true
            end})
            return {
                message = localize('k_duplicated_ex'),
            }
        end
    end,
    add = function(self, card)
        if card.ability.extra.active then
            local eval = function() return card.ability.extra.active end
            juice_card_until(card, eval, true)
        end
    end
})

bunc_define_joker({ -- Disproportionality
    name = 'Disproportionality', position = 45,
    vars = {{min = 0}, {max = 200}},
    custom_vars = function(self, info_queue, card)
        local r_chips = {}
        for i = card.ability.extra.min, card.ability.extra.max do
            r_chips[#r_chips + 1] = string.format("%03d", i)
        end
        local loc_chips = ' '..(G.localization.misc.dictionary.bunc_chips)..' '
        local text = {
            [1] = "[1] Lua local 'handler'",
            [2] = "at file 'chip_mod.lua:",
            [3] = "'",
            [4] = "ERROR",
            [5] = "Stack Traceback",
            [6] = "NOT A REAL BUG"
        }
        --for i = 1, #r_chips do
        --    r_chips[i] = text[2]..r_chips[i]..text[3]
        --end
        return {main_start =
        {{n = G.UIT.R, config = {align = "cm"}, nodes = {
            {n = G.UIT.R, config = {align = "cm", padding = 0.02}, nodes = {
                {n = G.UIT.O, config = {object = DynaText({string = {
                    {string = text[1]}, {string = text[1]}, {string = text[1]}, {string = text[1]}, {string = text[1]}, {string = text[1]},
                    {string = text[4], colour = G.C.JOKER_GREY},
                    {string = text[5]}, {string = text[6]},
                }, colours = {G.C.L_BLACK}, random_element = true, pop_in_rate = 9999999, silent = true, pop_delay = 0.2, scale = 0.32, min_cycle_time = 0})}},
            }},
            {n = G.UIT.R, config = {align = "cm", padding = 0.02}, nodes = {
                {n = G.UIT.T, config = {text = text[2], colour = G.C.L_BLACK, scale = 0.32}},
                {n = G.UIT.O, config = {object = DynaText({string = r_chips, colours = {G.C.CHIPS}, pop_in_rate = 9999999, silent = true, pop_delay = 0.005, scale = 0.32, min_cycle_time = 0})}},
                {n = G.UIT.T, config = {text = text[3], colour = G.C.L_BLACK, scale = 0.32}}
            }}
        }}}
        }
    end,
    rarity = 'Common', cost = 4,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if context.joker_main then
            local temp_chips = pseudorandom('disproportionality', card.ability.extra.min, card.ability.extra.max)
            return {
                chips = temp_chips,
            }
        end
    end
})

bunc_define_joker({ -- Running Joke
    name = 'Running Joke', position = 46,
    custom_vars = function(self, info_queue, card)
        info_queue[#info_queue+1] = G.P_CENTERS.e_negative
        info_queue[#info_queue+1] = G.P_CENTERS.j_joker
    end,
    rarity = 'Rare', cost = 8,
    blueprint = false, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if context.bunc_enter_shop then
            big_juice(card)
            local area = G.shop_jokers
            local shop_card = Card(area.T.x + area.T.w/2, area.T.y, G.CARD_W, G.CARD_H, nil, G.P_CENTERS['j_joker'],
            {bypass_discovery_center = area == G.shop_jokers,
            bypass_discovery_ui = area == G.shop_jokers,
            discover = area == G.shop_jokers,
            bypass_back = G.GAME.selected_back.pos})
            shop_card:set_edition({negative = true})
            create_shop_card_ui(shop_card)
            G.shop_jokers:emplace(shop_card)
        end
    end
})

bunc_define_joker({ -- On Broadway
    name = 'On Broadway', position = 47,
    vars = {{chips = 120}, {mult = 20}},
    rarity = 'Uncommon', cost = 6,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if context.joker_main and context.scoring_hand and context.poker_hands ~= nil and next(context.poker_hands['Straight']) then
            local face = false
            for i = 1, #context.scoring_hand do
                if context.scoring_hand[i]:is_face() then
                    face = true
                end
            end
            if face then
                return {
                    chips = card.ability.extra.chips,
                    mult = card.ability.extra.mult
                }
            end
        end
    end
})

bunc_define_joker({ -- Rasta
    name = 'Rasta', position = 48,
    vars = {{mult = 12}},
    rarity = 'Common', cost = 5,
    blueprint = true, eternal = true, perishable = true,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'win_custom' and not G.GAME.enhancements_used then
            unlock_card(self)
        end
    end,
    calculate = function(self, card, context)
        if context.joker_main and context.scoring_hand then
            local enhancement = false
            for i = 1, #context.scoring_hand do
                if context.scoring_hand[i].config.center ~= G.P_CENTERS.c_base then
                    enhancement = true
                end
            end
            if not enhancement then return {
                mult = card.ability.extra.mult,
                card = card
            } end
        end
        if context.joker_main and not context.scoring_hand then
            return {
                mult = card.ability.extra.mult,
                card = card
            }
        end
    end
})

bunc_define_joker({ -- Critic
    name = 'Critic', position = 49,
    vars = {{xmult = 2}, {fraction = 3}},
    rarity = 'Common', cost = 6,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if context.joker_main then
            local temp_chips = G.GAME.blind.chips
            if math.floor(hand_chips * mult) < (temp_chips / card.ability.extra.fraction) then return {
                xmult = card.ability.extra.xmult,
            } end
        end
    end
})

bunc_define_joker({ -- Cellphone
    name = 'Cellphone', position = 50,
    vars = {{active = true}, {cards_to_hand = {}}},
    rarity = 'Uncommon', cost = 8,
    blueprint = false, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if context.first_hand_drawn then
            card.ability.extra.active = true
            local eval = function() return card.ability.extra.active end
            juice_card_until(card, eval, true)
        end
        if context.joker_main and context.scoring_hand then
            card.ability.extra.cards_to_hand = context.scoring_hand
        end
        if context.bunc_press_play and card.ability.extra.active and G.GAME.current_round.hands_played == 0 then
            return {
                message = G.localization.misc.dictionary.bunc_accepted,
                colour = G.C.GREEN
            }
        end
        if context.after and G.GAME.current_round.hands_played == 0 then
            event({func = function ()
                if G.GAME.current_round.hands_played > 0 then
                    card.ability.extra.active = false
                end
                return true
            end})
        end
        if context.pre_discard and card.ability.extra.active then
            card.ability.extra.active = false
            return {
                message = G.localization.misc.dictionary.bunc_declined,
                colour = G.C.RED
            }
        end
    end,
    set_ability = function(self, card, initial, delay_sprites)
        if self.discovered or card.bypass_discovery_center then
            card.T.w = card.T.w / 1.11
        end
    end,
    set_sprites = function(self, card, front)
        if self.discovered or card.bypass_discovery_center then
            card.children.center.scale.x = card.children.center.scale.x / 1.11
        end
    end,
    load = function(self, card, card_table, other_card)
        return self.set_ability(self, card)
    end
})

bunc_define_joker({ -- Wino
    name = 'Wino', position = 51,
    vars = {{chips = 12}},
    rarity = 'Common', cost = 5,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if context.individual and context.cardarea == G.play then

            local other_card = context.other_card

            if context.other_card:is_suit('Hearts') or context.other_card:is_suit('Diamonds') then
                return {
                    chips = card.ability.extra.chips,
                    card = card
                }
            end
        end
    end
})

bunc_define_joker({ -- Bounty Hunter
    name = 'Bounty Hunter', position = 52,
    vars = {{bonus = 1}, {mult = 0}, {unlock = -20}, {being_sold = false}},
    locked_vars = function(self, info_queue, card)
        return {vars = {self.config.extra.unlock}}
    end,
    rarity = 'Common', cost = 5,
    blueprint = true, eternal = true, perishable = false,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'money' then
            if to_big(G.GAME.dollars) < to_big(self.config.extra.unlock) then
                unlock_card(self)
            end
        end
    end,
    calculate = function(self, card, context)
        if context.selling_card and context.card == card then
            card.ability.being_sold = true
        end
        if context.bunc_pre_money_change and context.sign == 1 and not context.blueprint then
            card.ability.extra.mult = card.ability.extra.mult + card.ability.extra.bonus
            local new_mod = to_big(context.mod) - to_big(card.ability.extra.bonus)
            if card.ability.being_sold then
                return {
                    bunc_new_dollars_mod = new_mod,
                    message = localize("bunc_robbed"),
                    colour = G.C.ORANGE,
                }
            else
                return {
                    bunc_new_dollars_mod = new_mod,
                    message = localize("bunc_robbed"),
                    colour = G.C.ORANGE,
                    extra = {
                        message = localize {
                            type = 'variable',
                            key = 'a_mult',
                            vars = {card.ability.extra.mult}
                        }
                    }
                }
            end
        end
        if context.joker_main and card.ability.extra.mult ~= 0 then
            return {
                mult = card.ability.extra.mult,
                card = card
            }
        end
    end
})

function create_UIBox_bunc_mousetrap_config()    
    local t = create_UIBox_generic_options({ contents = {
        {n=G.UIT.R, config={align = "cm", padding = 0.15, colour = G.C.CLEAR}, nodes={
            {n=G.UIT.C, config={align = "cm", padding = 0.15}, nodes={
                create_slider({label = G.localization.descriptions.Joker.j_bunc_mousetrap.name .. " (" .. G.localization.misc.dictionary.bunc_volume .. ")", w = 5, h = 0.4, ref_table = G.SETTINGS.SOUND, ref_value = 'bunc_mousetrap_volume', min = 0, max = 100}),
            }}
        }}
    }})
    return t
end
G.FUNCS.j_bunc_mousetrap_settings = function(e)
	G.FUNCS.overlay_menu{
		definition = create_UIBox_bunc_mousetrap_config(),
        config = {offset = {x=0,y=10}}
	}
end
bunc_define_joker({ -- Mousetrap
    name = 'Mousetrap', position = 53,
    vars = {{chips = 300}, {odds = 3}},
    custom_vars = function(self, info_queue, card)
        local vars = {card.ability.extra.chips, SMODS.get_probability_vars(card, 1, card.ability.extra.odds, 'bunc_mousetrap')}
        return {vars = vars}
    end,
    rarity = 'Uncommon', cost = 6,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if (context.end_of_round or context.hand_drawn or context.after) and card.children.center.sprite_pos.y == 15 then
            G.E_MANAGER:add_event(Event({
                trigger = 'immediate',
                func = function()
                    card:juice_up(0.3, 0.3)
                    local center = card.children.center
                    center:set_sprite_pos({ x = 2, y = 5 })
                    return true
                end
            }))
        end
        if context.joker_main then
            if SMODS.pseudorandom_probability(card, 'mousetrap'..G.SEED, 1, card.ability.extra.odds, 'bunc_mousetrap') then
                if G.GAME.current_round.hands_left ~= 0 then ease_hands_played(-1) end
                G.E_MANAGER:add_event(Event({
                    trigger = 'immediate',
                    func = function()
                        local center = card.children.center
                        center:set_sprite_pos({ x = 9, y = 15 })
                        return true
                    end
                }))
                if G.SETTINGS.SOUND.bunc_mousetrap_volume == 0 then
                    return {
                        message = G.localization.misc.dictionary.bunc_ouch,
                        colour = G.C.RED,
                    }
                else
                    return {
                        message = G.localization.misc.dictionary.bunc_ouch,
                        colour = G.C.RED,
                        sound = "bunc_mousetrap",
                        volume = G.SETTINGS.SOUND.bunc_mousetrap_volume / 100
                    }
                end
            else
                return {
                    chips = card.ability.extra.chips,
                }
            end
        end
    end
})

bunc_define_joker({ -- The Joker
    name = 'The Joker', custom_atlas = 'bunco_jokers_the_joker', position = 1,
    vars = {{trash_list = {}}, {odds = 3}},
    custom_vars = function(self, info_queue, card)
        local vars = {SMODS.get_probability_vars(card, 1, card.ability.extra.odds, "bunc_the_joker")}
        return {vars = vars}
    end,
    rarity = 'Rare', cost = 10,
    blueprint = false, eternal = true, perishable = true,
    unlocked = false,
    check_for_unlock = function(self, args)
        if args.type == 'discover_amount' then
            if G.DISCOVER_TALLIES.blinds.tally == G.DISCOVER_TALLIES.blinds.of then
                unlock_card(self)
            end
        end
    end,
    calculate = function(self, card, context)
        if not context.blueprint then
            if context.scoring_hand and not context.other_card then
                card.ability.extra.trash_list = {}
                for k, v in ipairs(context.scoring_hand) do
                    if v.config.center == G.P_CENTERS.c_base then
                        if SMODS.pseudorandom_probability(card, 'the_joker'..G.SEED, 1, card.ability.extra.odds, 'bunc_the_joker') then
                            table.insert(card.ability.extra.trash_list, v)
                        end
                    end
                end
            end

            if context.after then
                local trash_list = card.ability.extra.trash_list
                local dissolve_time_fac = 3

                if #trash_list ~= 0 then

                    event({
                        trigger = 'before',
                        delay = 0.7 * dissolve_time_fac * 1.051,
                        func = function()
                            big_juice(card)
                            play_sound('tarot2', 1.2, 0.4)
                            event({blocking = false, blockable = false, trigger = 'after', delay = 0.06*G.SETTINGS.GAMESPEED, func = function()
                                play_sound('tarot2', 0.96, 0.4)
                            return true end})
                            local destroyed_cards = {}
                            for _, card_to_trash in ipairs(trash_list) do
                                if not card_to_trash.removed then
                                    card_to_trash:start_dissolve(nil, nil, dissolve_time_fac)
                                    table.insert(destroyed_cards, card_to_trash)
                                end
                            end
                            if next(destroyed_cards) then
                                SMODS.calculate_context({remove_playing_cards = true, removed = destroyed_cards})
                            end
                            return true
                        end
                    })

                    for _, card_to_trash in ipairs(trash_list) do
                        card_to_trash.destroyed = true
                    end
                end
                card.ability.extra.trash_list = {}
            end
        end
    end,
    set_ability = function(self, card, initial, delay_sprites)
        if self.discovered or card.bypass_discovery_center then
            card.T.h = card.T.w
        end
    end,
    set_sprites = function(self, card, front)
        if self.discovered or card.bypass_discovery_center then
            card.children.center.scale.y = card.children.center.scale.x
        end
    end,
    load = function(self, card, card_table, other_card)
        return self.set_ability(self, card)
    end,
    update = function(self, card)
        if self.discovered or card.bypass_discovery_center then
            local timer = (G.TIMERS.REAL * G.ANIMATION_FPS * 2) + 20
            local frame_amount = 40
            local wrapped_value = (math.floor(timer) - 1) % frame_amount + 1
            card.children.center:set_sprite_pos({x = wrapped_value, y = card.children.center.sprite_pos.y})
        end
    end
})

bunc_define_joker({ -- Tangram
    name = 'Tangram', position = 54,
    vars = {{mult = 7}},
    rarity = 'Rare', cost = 7,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if context.individual and context.cardarea == G.play then

            local sevens = 0

            for k, v in ipairs(context.full_hand) do
                if v:get_id() == 7 then
                    sevens = sevens + 1
                end
            end

            if context.other_card:get_id() == 7 then
                return {
                    mult = card.ability.extra.mult * sevens,
                    card = card
                }
            end
        end
    end
})

bunc_define_joker({ -- Domino
    name = 'Domino', position = 55,
    rarity = 'Rare', cost = 12,
    blueprint = false, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if (context.buying_card or context.getting_booster_card) and context.pre_cardarea and not context.blueprint then

            local function acquire(acquired_card)
                acquired_card.area:remove_card(acquired_card)
                acquired_card:add_to_deck()
                if acquired_card.children.price then acquired_card.children.price:remove() end
                acquired_card.children.price = nil
                if acquired_card.children.buy_button then acquired_card.children.buy_button:remove() end
                acquired_card.children.buy_button = nil
                remove_nils(acquired_card.children)
                if acquired_card.ability.set == 'Default' or acquired_card.ability.set == 'Enhanced' then
                    inc_career_stat('c_playing_cards_bought', 1)
                    G.playing_card = (G.playing_card and G.playing_card + 1) or 1
                    G.deck:emplace(acquired_card)
                    acquired_card.playing_card = G.playing_card
                    playing_card_joker_effects({acquired_card})
                    table.insert(G.playing_cards, acquired_card)
                else
                    if acquired_card.ability.consumeable then
                        G.consumeables:emplace(acquired_card)
                    else
                        G.jokers:emplace(acquired_card)
                    end
                    event({func = function() acquired_card:calculate_joker({buying_card = true, card = acquired_card}) return true end})
                end
                --Tallies for unlocks
                G.GAME.round_scores.cards_purchased.amt = G.GAME.round_scores.cards_purchased.amt + 1
                if acquired_card.ability.consumeable then
                    if acquired_card.config.center.set == 'Planet' then
                        inc_career_stat('c_planets_bought', 1)
                    elseif acquired_card.config.center.set == 'Tarot' then
                        inc_career_stat('c_tarots_bought', 1)
                    end
                elseif acquired_card.ability.set == 'Joker' then
                    G.GAME.current_round.jokers_purchased = G.GAME.current_round.jokers_purchased + 1
                end
            end

            local card_pos = context.pre_card_pos
            if card_pos then
                -- Aquire left then right card

                local left_card = context.pre_card_left
                local right_card = context.pre_card_right
                if left_card and left_card.area ~= G.consumeables then
                    if G.FUNCS.check_for_buy_space(left_card) and 
                        (left_card.ability.consumeable or 
                        left_card.ability.set == 'Enhanced' or 
                        left_card.ability.set == 'Default' or 
                        left_card.ability.set == 'Joker')
                    then
                        acquire(left_card)
                        big_juice(card)
                    end
                end
                if right_card and right_card.area ~= G.consumeables then
                    if G.FUNCS.check_for_buy_space(right_card) and 
                        (right_card.ability.consumeable or 
                        right_card.ability.set == 'Enhanced' or 
                        right_card.ability.set == 'Default' or 
                        right_card.ability.set == 'Joker')
                    then
                        acquire(right_card)
                        big_juice(card)
                    end
                end

                -- If all cards from booster have been aquired then close booster
                -- by setting choices to zero
                if G.STATE == G.STATES.STANDARD_PACK
                or G.STATE == G.STATES.BUFFOON_PACK
                or G.STATE == G.STATES.TAROT_PACK
                or G.STATE == G.STATES.PLANET_PACK
                or G.STATE == G.STATES.SPECTRAL_PACK
                or G.STATE == G.STATES.SMODS_BOOSTER_OPENED then
                    if context.pre_cardarea == G.pack_cards and #context.pre_cardarea.cards == 0 then
                        G.GAME.pack_choices = 0
                    end
                end
            end
        end
    end,
    set_ability = function(self, card, initial, delay_sprites)
        if self.discovered or card.bypass_discovery_center then
            card.T.w = card.T.w / 1.5
        end
    end,
    set_sprites = function(self, card, front)
        if self.discovered or card.bypass_discovery_center then
            card.children.center.scale.x = card.children.center.scale.x / 1.5
        end
    end,
    load = function(self, card, card_table, other_card)
        return self.set_ability(self, card)
    end
})

bunc_define_joker({ -- Glue Gun
    name = 'Glue Gun', position = 56,
    vars = {{amount = 4}},
    custom_vars = function (self, info_queue, card)

        info_queue[#info_queue+1] = {set = 'Other', key = 'bunc_linked_group'}

        local active = (G.hand and G.hand.highlighted and (#G.hand.highlighted > 1) and (#G.hand.highlighted <= card.ability.extra.amount)) or false
        local main_end = {
            {n=G.UIT.C, config={align = "bm", minh = 0.4}, nodes={
                {n=G.UIT.C, config={ref_table = self, align = "m", colour = active and G.C.GREEN or G.C.RED, r = 0.05, padding = 0.06}, nodes={
                    {n=G.UIT.T, config={text = ' '..localize(active and 'k_active' or 'bunc_inactive')..' ',colour = G.C.UI.TEXT_LIGHT, scale = 0.32*0.9}},
                }}
            }}
        }
        return {vars = {card.ability.extra.amount}, main_end = main_end}
    end,
    rarity = 'Uncommon', cost = 4,
    blueprint = false, eternal = false, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if context.selling_self and not context.blueprint then
            event({func = function()
                if G.hand and G.hand.highlighted and (#G.hand.highlighted > 1) and (#G.hand.highlighted <= card.ability.extra.amount) then

                    for i = 1, #G.hand.highlighted do
                        if G.hand.highlighted[i].ability.group then return true end
                    end

                    link_cards(G.hand.highlighted, self.key)
                    for i = 1, #G.hand.highlighted do
                        big_juice(G.hand.highlighted[i])
                    end
                end
            return true end})
        end
    end
})

bunc_define_joker({ -- Taped
    name = 'Taped', custom_atlas = 'bunco_jokers_taped', position = 1,
    custom_vars = function (self, info_queue, card)
        info_queue[#info_queue+1] = {set = 'Other', key = 'bunc_linked_group'}
    end,
    rarity = 'Rare', cost = 6,
    blueprint = false, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if context.before
        and context.full_hand
        and not context.other_card
        and G.GAME.current_round.hands_played == 0
        and G.GAME.blind.boss
        and not context.blueprint then
            event({func = function()

                local cards = {}

                for i = 1, #context.full_hand do
                    if not context.full_hand[i].ability.group then
                        table.insert(cards, context.full_hand[i])
                    end
                end

                if #cards > 1 then
                    link_cards(cards, self.key)
                    big_juice(card)

                    for i = 1, #cards do
                        big_juice(cards[i])
                    end
                end

            return true end})
        end
    end,
    set_ability = function(self, card, initial, delay_sprites)
        if self.discovered or card.bypass_discovery_center then
            card.T.w = G.CARD_W * 1.788732394366197
            card.T.h = G.CARD_H * 1.189473684210526
        end
    end,
    set_sprites = function(self, card, front)
        if self.discovered or card.bypass_discovery_center then
            card.children.center.scale = {x = 127, y = 113}
            card.children.center:reset()
        end
    end,
    load = function(self, card, card_table, other_card)
        return self.set_ability(self, card)
    end
})

bunc_define_joker({ -- Rubber Band Ball
    name = 'Rubber Band Ball', position = 57,
    vars = {{bonus = 1}, {xmult = 1}},
    custom_vars = function (self, info_queue, card)
        info_queue[#info_queue+1] = {set = 'Other', key = 'bunc_linked_group'}
        return {vars = {card.ability.extra.bonus, card.ability.extra.xmult}}
    end,
    rarity = 'Uncommon', cost = 6,
    blueprint = true, eternal = true, perishable = false,
    unlocked = true,
    calculate = function(self, card, context)
        if context.joker_main then
            if card.ability.extra.xmult ~= 1 then
                return {
                    xmult = card.ability.extra.xmult,
                }
            end
        end
    end,
    update = function(self, card)
        card.ability.extra.xmult = (G.GAME.last_card_group and G.GAME.last_card_group + 1 or 1) * card.ability.extra.bonus
    end,
    custom_in_pool = function()
        return G.GAME.last_card_group
    end,
})

bunc_define_joker({ -- Headache
    name = 'Headache', custom_atlas = 'bunco_jokers_headache', position = 1,
    vars = {{amount = 4}, {destroyed = 0}},
    custom_vars = function (self, info_queue, card)
        info_queue[#info_queue+1] = {set = 'Tag', key = 'tag_bunc_arcade'}
        info_queue[#info_queue + 1] = {key = 'p_bunc_virtual_mega', set = 'Other', vars = {G.P_CENTERS.p_bunc_virtual_mega.config.choose, G.P_CENTERS.p_bunc_virtual_mega.config.extra}}
        return {vars = {card.ability.extra.amount, card.ability.extra.destroyed}}
    end,
    rarity = 'Uncommon', cost = 4,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if context.remove_playing_cards then
            card.ability.extra.destroyed = card.ability.extra.destroyed + #context.removed
            while card.ability.extra.destroyed >= card.ability.extra.amount do
                add_tag(Tag('tag_bunc_arcade'))
                forced_message('+1 '..localize{type = 'name_text', key = 'tag_bunc_arcade', set = 'Tag'}, card, G.C.BUNCO_VIRTUAL)
                card.ability.extra.destroyed = card.ability.extra.destroyed - card.ability.extra.amount
            end
        end
    end,
    set_sprites = function(self, card, front)
        if card.config.center.discovered or card.bypass_discovery_center then
            card.children.floating_sprite = Sprite(card.T.x, card.T.y, card.T.w, card.T.h, G.ASSET_ATLAS['bunc_bunco_jokers_border'], coordinate_from_atlas_index(1))
            card.children.floating_sprite.states.hover = card.states.hover
            card.children.floating_sprite.states.click = card.states.click
            card.children.floating_sprite.states.drag = card.states.drag
            card.children.floating_sprite.states.collide.can = false
            card.children.floating_sprite:set_role({major = card, role_type = 'Glued', draw_major = card})
        end
        card.draw_bypass = {floating_sprite = true}
    end,
    drawsteps = {
        {
            order = 21,
            func = function(card, layer)
                if card.config.center.key == 'j_bunc_headache' and (card.config.center.discovered or card.bypass_discovery_center) then

                    local realw, realh = love.window.getMode()

                    card.children.center:draw_shader('bunc_headache', nil, {
                    [1] = (((card.tilt_var.mx) - realw / 2) * 0.3)   +   ((card.VT.x + G.ROOM.T.x + (card.VT.w / 2)) * G.TILESIZE * G.TILESCALE - realw / 2) * -0.2,
                    [2] = (((card.tilt_var.my) - realh / 2) * 0.8)   +   ((card.VT.y + G.ROOM.T.y + (card.VT.h / 2)) * G.TILESIZE * G.TILESCALE - realh / 2) * -0.4,
                    [3] = G.TIMERS.REAL
                    })
                end
            end
        },
        {
            order = 61,
            func = function(card, layer)
                if card.config.center.key == 'j_bunc_headache' and (card.config.center.discovered or card.bypass_discovery_center) then
                    card.children.floating_sprite:draw_shader('dissolve', nil, nil, nil, card.children.center, 0, 0)
                    if card.edition then
                        for k, v in pairs(G.P_CENTER_POOLS.Edition) do
                            if card.edition[v.key:sub(3)] and v.shader then
                                card.children.floating_sprite:draw_shader(v.shader, nil, card.ARGS.send_to_shader, nil, card.children.center, 0, 0)
                            end
                        end
                    end
                end
            end
        }
    }
})

bunc_define_joker({ -- Games Collector
    name = 'Games Collector', position = 58,
    vars = {{bonus = 10}, {chips = 0}, {drawn_this_round = {}}},
    custom_vars = function (self, info_queue, card)
        info_queue[#info_queue+1] = {set = 'Other', key = 'bunc_linked_group'}
        return {vars = {card.ability.extra.bonus, card.ability.extra.chips}}
    end,
    rarity = 'Common', cost = 5,
    blueprint = true, eternal = true, perishable = false,
    unlocked = true,
    calculate = function(self, card, context)

        -- Note:
        -- Due to the way this is coded, it will only trigger
        -- upon the group breaking the hand limit.
        -- That means that if you managed to draw a group
        -- "naturally" (so it didn't request other cards)
        -- the Joker won't recieve its bonus

        if context.bunc_groups_drawn and not context.blueprint then
            local upgrade = false
            for _, group_id in ipairs(context.bunc_groups_drawn) do
                if not card.ability.extra.drawn_this_round[group_id] then
                    card.ability.extra.chips = card.ability.extra.chips + card.ability.extra.bonus
                    card.ability.extra.drawn_this_round[group_id] = true
                    upgrade = true
                end
            end
            if upgrade then
                return {
                    message = localize('k_upgrade_ex'),
                    colour = G.C.CHIPS
                }
            end
        end
        if context.joker_main then
            if card.ability.extra.chips ~= 0 then
                return {
                    chips = card.ability.extra.chips,
                    card = card
                }
            end
        end
        if context.end_of_round then
            card.ability.extra.drawn_this_round = {}
        end
    end,
    custom_in_pool = function()
        return G.GAME.last_card_group
    end
})

bunc_define_joker({ -- Jumper
    name = 'Jumper', position = 59,
    vars = {{bonus = 8}, {chips = 0}},
    rarity = 'Common', cost = 5,
    blueprint = true, eternal = true, perishable = false,
    unlocked = true,
    calculate = function(self, card, context)
        if context.before then
            if context.poker_hands and next(context.poker_hands['Flush']) and not context.blueprint then
                card.ability.extra.chips = card.ability.extra.chips + card.ability.extra.bonus
                return {
                    message = localize('k_upgrade_ex'),
                    colour = G.C.CHIPS,
                    card = card
                }
            end
        end
        if context.joker_main then
            if card.ability.extra.chips ~= 0 then
                return {
                    chips = card.ability.extra.chips,
                    card = card
                }
            end
        end
    end
})

function create_UIBox_bunc_stylophone_config()    
    local t = create_UIBox_generic_options({ contents = {
        {n=G.UIT.R, config={align = "cm", padding = 0.15, colour = G.C.CLEAR}, nodes={
            {n=G.UIT.C, config={align = "cm", padding = 0.15}, nodes={
                create_slider({label = G.localization.descriptions.Joker.j_bunc_stylophone.name .. " (" .. G.localization.misc.dictionary.bunc_volume .. ")", w = 5, h = 0.4, ref_table = G.SETTINGS.SOUND, ref_value = 'bunc_stylophone_volume', min = 0, max = 100}),
            }}
        }}
    }})
    return t
end
G.FUNCS.j_bunc_stylophone_settings = function(e)
	G.FUNCS.overlay_menu{
		definition = create_UIBox_bunc_stylophone_config(),
        config = {offset = {x=0,y=10}}
	}
end
bunc_define_joker({ -- Stylophone
    name = 'Stylophone', position = 60,
    vars = {{x = 0.3}},
    rarity = 'Uncommon', cost = 5,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)

        local function play_stylophone(other_card)
            if G.SETTINGS.SOUND.bunc_stylophone_volume == 0 then
                return
            end
            local instrument = 'bunc_stone'

            local function calculate_pitch(pitch)
                return 2^(pitch / 12)
            end

            if SMODS.has_no_rank(other_card) then
                event({trigger = 'after', func = function() play_sound(instrument, 1.0, 2.0) return true end})
            else
                -- For a theoretical suitless card with a rank
                if not SMODS.has_no_suit(other_card) then
                    if other_card.base.suit == 'Spades' then
                        instrument = 'bunc_spade'
                    elseif other_card.base.suit == 'Clubs' then
                        instrument = 'bunc_club'
                    elseif other_card.base.suit == 'Hearts' then
                        instrument = 'bunc_heart'
                    elseif other_card.base.suit == 'Diamonds' then
                        instrument = 'bunc_diamond'
                    elseif other_card.base.suit == 'bunc_Fleurons' then
                        instrument = 'bunc_fleuron'
                    elseif other_card.base.suit == 'bunc_Halberds' then
                        instrument = 'bunc_halberd'
                    elseif other_card.base.suit == 'paperback_Stars' then
                        instrument = 'bunc_paperback_star'
                    elseif other_card.base.suit == 'paperback_Crowns' then
                        instrument = 'bunc_paperback_crown'
                    elseif other_card.base.suit == 'minty_3s' then
                        instrument = 'bunc_minty_3'
                    end
                end
                event({trigger = 'after', func = function() play_sound(instrument, calculate_pitch(other_card:get_id()), 2.0 * G.SETTINGS.SOUND.bunc_stylophone_volume / 100) return true end})
            end
        end

        if context.individual and context.cardarea == G.play then
            if G.SETTINGS.SOUND.bunc_stylophone_volume > 0 then
                play_stylophone(context.other_card)
            end
            if not SMODS.has_no_rank(context.other_card) then
                return {
                    mult = context.other_card:get_id() * card.ability.extra.x,
                    card = card
                }
            end
        end
        if context.click and context.other_card.area == G.hand and G.SETTINGS.SOUND.bunc_stylophone_volume > 0 then
            extra_juice(card)
            play_stylophone(context.other_card)
        end
    end
})

bunc_define_joker({ -- Kite Experiment
    name = 'Kite Experiment', position = 61,
    vars = {{odds = 2}, {cards_rescored = {}}},
    custom_vars = function(self, info_queue, card)
        info_queue[#info_queue+1] = G.P_CENTERS.m_bunc_copper
        local vars = {SMODS.get_probability_vars(card, 1, card.ability.extra.odds, "bunc_kite_experiment")}
        return {vars = vars}
    end,
    rarity = 'Uncommon', cost = 6,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true,
    custom_in_pool = function()
        local condition = false
        if G.playing_cards then
            for k, v in pairs(G.playing_cards) do
                if v.config.center == G.P_CENTERS.m_bunc_copper then condition = true break end
            end
        end
        return condition
    end,
    calculate = function(self, card, context)
        if context.rescore_cards then
            local condition = true

            for i = 1, #card.ability.extra.cards_rescored do
                if context.rescore_cards[1] == card.ability.extra.cards_rescored[i] then
                    condition = false
                end
            end

            if condition and SMODS.pseudorandom_probability(card, 'kite_experiment'..G.SEED, 1, card.ability.extra.odds, 'bunc_kite_experiment') then
                context.rescore_cards[1].config.copper_rescored_times = context.rescore_cards[1].config.copper_rescored_times - 1
                table.insert(card.ability.extra.cards_rescored, context.rescore_cards[1])
                return {
                    message = '+1',
                    card = card
                }
            end
        end
        if context.after then
            card.ability.extra.cards_rescored = {}
        end
    end
})

bunc_define_joker({ -- Robot
    name = 'Robot', position = 62,
    vars = {{bonus = 3}, {mult = 0}},
    custom_vars = function(self, info_queue, card)
        info_queue[#info_queue+1] = G.P_CENTERS.m_bunc_copper
        return {vars = {card.ability.extra.bonus, card.ability.extra.mult}}
    end,
    rarity = 'Uncommon', cost = 6,
    blueprint = true, eternal = true, perishable = false,
    unlocked = true,
    custom_in_pool = function()
        local condition = false
        if G.playing_cards then
            for k, v in pairs(G.playing_cards) do
                if v.config.center == G.P_CENTERS.m_bunc_copper then condition = true break end
            end
        end
        return condition
    end,
    calculate = function(self, card, context)
        if context.rescore_cards and not context.blueprint then

            card.ability.extra.mult = card.ability.extra.mult + (card.ability.extra.bonus * #context.rescore_cards)

            return {
                message = localize('k_upgrade_ex'),
                card = card
            }
        end
        if context.joker_main then
            if card.ability.extra.mult ~= 0 then
                return {
                    mult = card.ability.extra.mult,
                    card = card
                }
            end
        end
    end
})

bunc_define_joker({ -- Hardtack
    name = 'Hardtack', position = 63,
    custom_vars = function(self, info_queue, card)
        info_queue[#info_queue+1] = G.P_CENTERS.m_bunc_cracker
    end,
    rarity = 'Uncommon', cost = 5,
    blueprint = true, eternal = true, perishable = false,
    unlocked = true,
    custom_in_pool = function()
        local condition = false
        if G.playing_cards then
            for k, v in pairs(G.playing_cards) do
                if v.config.center == G.P_CENTERS.m_bunc_cracker then condition = true break end
            end
        end
        return condition
    end
})

bunc_define_joker({ -- Pica
    name = 'Pica', position = 64,
    custom_vars = function(self, info_queue, card)
        info_queue[#info_queue+1] = G.P_CENTERS.m_bunc_cracker
    end,
    rarity = 'Uncommon', cost = 5,
    blueprint = true, eternal = true, perishable = false,
    unlocked = true,
    custom_in_pool = function()
        local condition = false
        if G.playing_cards then
            for k, v in pairs(G.playing_cards) do
                if v.config.center == G.P_CENTERS.m_bunc_cracker then condition = true break end
            end
        end
        return condition
    end
})

-- Exotic Jokers

bunc_define_joker({ -- Zealous
    type = 'Exotic',
    name = 'Zealous', position = 1,
    custom_vars = function(self, info_queue, card) return {vars = {card.ability.t_mult}} end,
    custom_config = {t_mult = 10, type = 'bunc_Spectrum'},
    rarity = 'Common', cost = 3,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true
})

bunc_define_joker({ -- Lurid
    type = 'Exotic',
    name = 'Lurid', position = 2,
    custom_vars = function(self, info_queue, card) return {vars = {card.ability.t_chips}} end,
    custom_config = {t_chips = 80, type = 'bunc_Spectrum'},
    rarity = 'Common', cost = 3,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true
})

bunc_define_joker({ -- Envious
    type = 'Exotic',
    name = 'Envious', position = 3,
    vars = {{s_mult = 6}, {suit = 'bunc_Fleurons'}},
    rarity = 'Common', cost = 5,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true,
    effect = 'Suit Mult'
})

bunc_define_joker({ -- Proud
    type = 'Exotic',
    name = 'Proud', position = 4,
    vars = {{s_mult = 6}, {suit = 'bunc_Halberds'}},
    rarity = 'Common', cost = 5,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true,
    effect = 'Suit Mult'
})

bunc_define_joker({ -- Wishalloy
    type = 'Exotic',
    name = 'Wishalloy', position = 5,
    vars = {{odds = 7}},
    custom_vars = function(self, info_queue, card)
        local vars = {SMODS.get_probability_vars(card, 1, card.ability.extra.odds, "bunc_wishalloy")}
        return {vars = vars}
    end,
    rarity = 'Uncommon', cost = 7,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if context.individual and context.cardarea == G.play and context.other_card:is_suit('bunc_Fleurons') then
            if SMODS.pseudorandom_probability(card, 'wishalloy'..G.SEED, 1, card.ability.extra.odds, 'bunc_wishalloy') then
                local value = context.other_card:get_chip_bonus()
                return {
                    dollars = value,
                }
            end
        end
    end
})

bunc_define_joker({ -- Unobtanium
    type = 'Exotic',
    name = 'Unobtanium', position = 6,
    vars = {{chips = 30}, {mult = 6}},
    rarity = 'Uncommon', cost = 7,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if context.individual and context.cardarea == G.play and context.other_card:is_suit('bunc_Halberds') then
            return {
                message = localize {
                    type = 'variable',
                    key = 'a_mult',
                    vars = {card.ability.extra.mult}
                },
                chips = card.ability.extra.chips,
                mult = card.ability.extra.mult,
                card = card
            }
        end
    end
})

bunc_define_joker({ -- Dynasty
    type = 'Exotic',
    name = 'Dynasty', position = 7,
    custom_vars = function(self, info_queue, card) return {vars = {card.ability.x_mult}} end,
    custom_config = {Xmult = 5, type = 'bunc_Spectrum'},
    rarity = 'Rare', cost = 8,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true
})

bunc_define_joker({ -- Magic Wand
    type = 'Exotic',
    name = 'Magic Wand', position = 8,
    vars = {{bonus = 3}, {mult = 0}},
    rarity = 'Common', cost = 5,
    blueprint = true, eternal = true, perishable = false,
    unlocked = true,
    calculate = function(self, card, context)
        if context.before and context.poker_hands ~= nil and next(context.poker_hands['bunc_Spectrum']) and not context.blueprint then
            card.ability.extra.mult = card.ability.extra.mult + card.ability.extra.bonus
        elseif context.after and context.poker_hands ~= nil and not next(context.poker_hands['bunc_Spectrum']) and not context.blueprint then
            if card.ability.extra.mult ~= 0 then
                card.ability.extra.mult = 0
                return {
                    message = localize('k_reset'),
                    colour = G.C.RED
                }
            end
        end

        if context.joker_main then
            if card.ability.extra.mult ~= 0 then
                return {
                    mult = card.ability.extra.mult,
                    card = card
                }
            end
        end
    end
})

bunc_define_joker({ -- Starfruit
    type = 'Exotic',
    name = 'Starfruit', position = 9,
    vars = {{odds = 4}},
    custom_vars = function(self, info_queue, card)
        local vars = {SMODS.get_probability_vars(card, 1, card.ability.extra.odds, "bunc_starfruit")}
        return {vars = vars}
    end,
    rarity = 'Uncommon', cost = 5,
    blueprint = false, eternal = false, perishable = true,
    unlocked = true,
    pools = {
        Food = true
    },
    calculate = function(self, card, context)
        if context.before and context.poker_hands ~= nil and next(context.poker_hands['bunc_Spectrum']) and not context.blueprint then
            return {
                message = localize('k_level_up_ex'),
                colour = G.C.RED,
                func = function()
                    level_up_hand(card, context.scoring_name, false, 1)
                end
            }
        end

        if context.end_of_round and not context.other_card and not context.blueprint then
            if SMODS.pseudorandom_probability(card, 'starfruit'..G.SEED, 1, card.ability.extra.odds, 'bunc_starfruit') then
                event({func = function()
                    card:start_dissolve()
                    return true
                end})
                return {
                    message = localize('k_eaten_ex'),
                    G.C.FILTER
                }
            else
                return {
                    message = localize('k_safe_ex')
                }
            end
        end
    end
})

bunc_define_joker({ -- Fondue
    type = 'Exotic',
    name = 'Fondue', position = 10,
    rarity = 'Rare', cost = 8,
    blueprint = false, eternal = true, perishable = true,
    unlocked = true,
    pools = {
        Food = true
    },
    calculate = function(self, card, context)
        if context.after and G.GAME.current_round.hands_played == 0 and context.scoring_hand and not context.blueprint then
            enable_exotics()

            for i = 1, #context.scoring_hand do
                event({trigger = 'after', delay = 0.15, func = function() context.scoring_hand[i]:flip(); play_sound('card1', 1); context.scoring_hand[i]:juice_up(0.3, 0.3); return true end })
            end

            for i = 1, #context.scoring_hand do
                event({trigger = 'after', delay = 0.1,  func = function() context.scoring_hand[i]:change_suit('bunc_Fleurons'); return true end })
            end

            for i = 1, #context.scoring_hand do
                event({trigger = 'after', delay = 0.15, func = function() context.scoring_hand[i]:flip(); play_sound('tarot2', 1, 0.6); big_juice(card); context.scoring_hand[i]:juice_up(0.3, 0.3); return true end })
            end

            delay(0.7 * 1.25)
        end
    end
})

BUNCOMOD.funcs.myopia_check = function (card, suit)
    if not next(SMODS.find_card('j_bunc_myopia')) then
        return false
    end
    if card.base.suit == 'Spades' and ((card.base.suit == 'Spades') == (suit == 'Spades' or suit == 'bunc_Halberds')) then
        return true
    end
    if card.base.suit == 'Clubs' and ((card.base.suit == 'Clubs') == (suit == 'Clubs' or suit == 'bunc_Halberds')) then
        return true
    end
    return false
end
bunc_define_joker({ -- Myopia
    type = 'Exotic',
    name = 'Myopia', position = 11,
    rarity = 'Uncommon', cost = 8,
    blueprint = false, eternal = true, perishable = true,
    unlocked = true
})

BUNCOMOD.funcs.astigmatism_check = function (card, suit)
    if not next(SMODS.find_card('j_bunc_myopia')) then
        return false
    end
    if card.base.suit == 'Hearts' and (card.base.suit == 'Hearts') == (suit == 'Hearts' or suit == 'bunc_Fleurons') then
        return true
    end
    if card.base.suit == 'Diamonds' and (card.base.suit == 'Diamonds') == (suit == 'Diamonds' or suit == 'bunc_Fleurons') then
        return true
    end
    return false
end
bunc_define_joker({ -- Astigmatism
    type = 'Exotic',
    name = 'Astigmatism', position = 12,
    rarity = 'Uncommon', cost = 8,
    blueprint = false, eternal = true, perishable = true,
    unlocked = true
})

bunc_define_joker({ -- ROYGBIV
    type = 'Exotic',
    name = 'ROYGBIV', position = 13,
    vars = {{odds = 7}},
    custom_vars = function(self, info_queue, card)

        info_queue[#info_queue+1] = G.P_CENTERS.e_polychrome

        local vars = {SMODS.get_probability_vars(card, 1, card.ability.extra.odds, "bunc_roygbiv")}
        return {vars = vars}
    end,
    rarity = 'Uncommon', cost = 8,
    blueprint = true, eternal = true, perishable = true,
    unlocked = true,
    calculate = function(self, card, context)
        if context.before and context.poker_hands ~= nil and next(context.poker_hands['bunc_Spectrum']) and context.scoring_hand and not context.blueprint then
            if SMODS.pseudorandom_probability(card, 'roygbiv'..G.SEED, 1, card.ability.extra.odds, 'bunc_roygbiv') then
                if context.scoring_hand then

                    local cards = {}

                    for i = 1, #context.scoring_hand do
                        if context.scoring_hand[i]:get_edition() == nil then
                            table.insert(cards, context.scoring_hand[i])
                        end
                    end

                    if cards and #cards > 0 then
                        event({func = function()
                            for i = 1, #cards do
                                local other_card = cards[i]
                                other_card:set_edition({polychrome = true}, true, true)
                                other_card:juice_up()
                            end
                            play_sound('polychrome1', 1.2, 0.7)
                            return true
                        end})
                        return {
                            message = '+'..localize{type = 'name_text', key = 'e_polychrome', set = 'Edition'}
                        }
                    end
                end
            end
        end
    end
})

-- Legendary Jokers

bunc_define_joker({ -- Rigoletto
    type = 'Exotic',
    name = 'Rigoletto', position = 1,
    vars = {{bonus = 0.2}, {xmult = 1}, {tally = 0}},
    custom_vars = function(self, info_queue, card)
        info_queue[#info_queue+1] = {set = 'Other', key = 'bunc_exotic_cards'}
        return {vars = {card.ability.extra.bonus, card.ability.extra.xmult}}
    end,
    rarity = 'Legendary', cost = 20,
    blueprint = true, eternal = true, perishable = false,
    unlocked = false,
    unlock_condition = {hidden = true},
    calculate = function(self, card, context)
        if context.joker_main then
            if card.ability.extra.xmult ~= 1 then
                return {
                    xmult = card.ability.extra.xmult,
                }
            end
        end
    end,
    update = function(self, card)
        if G.playing_cards ~= nil then
            card.ability.extra.tally = 0

            for k, v in pairs(G.playing_cards) do
                if v:is_suit('bunc_Fleurons') or v:is_suit('bunc_Halberds') then card.ability.extra.tally = card.ability.extra.tally + 1 end
            end

            card.ability.extra.xmult = 1 + (card.ability.extra.tally * card.ability.extra.bonus)
        end
    end
})

-- Tarots

SMODS.Atlas({key = 'bunco_tarots', path = 'Consumables/Tarots.png', px = 71, py = 95})
SMODS.Atlas({key = 'bunco_tarots_exotic', path = 'Consumables/TarotsExotic.png', px = 71, py = 95})

SMODS.Consumable{ -- Adjustment
    set = 'Tarot', atlas = 'bunco_tarots',
    key = 'adjustment',

    effect = 'Enhance',
    config = {mod_conv = 'm_bunc_cracker', max_highlighted = 2},
    pos = coordinate_from_atlas_index(1),

    set_card_type_badge = function(self, card, badges)
        badges[1] = create_badge(G.localization.misc.dictionary.bunc_thoth_tarot, get_type_colour(self or card.config, card), nil, 1.2)
    end,

    loc_vars = function(self, info_queue)
        info_queue[#info_queue+1] = G.P_CENTERS.m_bunc_cracker
        return {vars = {self.config.max_highlighted, localize{type = 'name_text', set = 'Enhanced', key = self.config.mod_conv}}}
    end,
}

SMODS.Consumable{ -- The Art
    set = 'Tarot', atlas = 'bunco_tarots',
    key = 'art',

    effect = 'Enhance',
    config = {mod_conv = 'm_bunc_copper', max_highlighted = 2},
    pos = coordinate_from_atlas_index(2),

    set_card_type_badge = function(self, card, badges)
        badges[1] = create_badge(G.localization.misc.dictionary.bunc_thoth_tarot, get_type_colour(self or card.config, card), nil, 1.2)
    end,

    loc_vars = function(self, info_queue)
        info_queue[#info_queue+1] = G.P_CENTERS.m_bunc_copper
        return {vars = {self.config.max_highlighted, localize{type = 'name_text', set = 'Enhanced', key = self.config.mod_conv}}} 
    end,
}

SMODS.Consumable{ -- The Universe
    set = 'Tarot', atlas = 'bunco_tarots',
    key = 'universe',

    config = {max_highlighted = 3},
    pos = coordinate_from_atlas_index(3),

    set_card_type_badge = function(self, card, badges)
        badges[1] = create_badge(G.localization.misc.dictionary.bunc_thoth_tarot, get_type_colour(self or card.config, card), nil, 1.2)
    end,

    loc_vars = function(self, info_queue)
        return {vars = {self.config.max_highlighted}}
    end,

    can_use = function(self, card)
        if G.hand and (#G.hand.highlighted >= 1) and (#G.hand.highlighted <= self.config.max_highlighted) then
            return true
        end
    end,

    use = function(self, card)
        local i
        for _, playing_card in ipairs(G.hand.cards) do
            if playing_card.highlighted then

                local new_seal = SMODS.poll_seal({guaranteed = true, key = 'universe'})
                local new_enhancement = SMODS.poll_enhancement({guaranteed = true, key = 'universe'})
                local new_edition = poll_edition('universe', nil, true, true)
                local new_suit = pseudorandom_element(SMODS.Suits, pseudoseed('universe')).key
                local new_rank = pseudorandom_element(SMODS.Ranks, pseudoseed('universe')).key

                event({delay = 0.2, trigger = 'before', func = function()

                    i = i and (i + 1) or 1
                    play_sound('card1', 0.85 + (i * 0.05))
                    big_juice(playing_card)

                    if playing_card.seal then
                        playing_card:set_seal(new_seal, true, true)
                    end

                    if playing_card.config.center ~= G.P_CENTERS.c_base then
                        playing_card:set_ability(G.P_CENTERS[new_enhancement])
                    end

                    if playing_card.edition then
                        playing_card:set_edition(new_edition, true)
                    end

                    SMODS.change_base(playing_card, new_suit, new_rank)

                return true end})
            end
        end
    end,
}

SMODS.Consumable{ -- Lust
    set = 'Tarot', atlas = 'bunco_tarots',
    key = 'lust',

    config = {bonus = 1, limit = 52},
    pos = coordinate_from_atlas_index(4),

    set_card_type_badge = function(self, card, badges)
        badges[1] = create_badge(G.localization.misc.dictionary.bunc_thoth_tarot, get_type_colour(self or card.config, card), nil, 1.2)
    end,

    loc_vars = function(self, info_queue)
        local reward = 0
        if G.hand and G.hand.cards and (#G.hand.cards > 0) then
            reward = #G.hand.cards * self.config.bonus
        end
        return {vars = {self.config.bonus, self.config.limit, (reward <= self.config.limit) and reward or self.config.limit}}
    end,

    can_use = function(self, card)
        if G.hand and G.hand.cards and (#G.hand.cards > 0) then
            return true
        end
    end,

    use = function(self, card)
        local reward = #G.hand.cards * self.config.bonus
        ease_dollars((reward <= self.config.limit) and reward or self.config.limit)
    end,
}

SMODS.Consumable{ -- The Sky
    set = 'Tarot', atlas = 'bunco_tarots_exotic',
    key = 'sky',
    set_card_type_badge = function(self, card, badges)
        badges[1] = create_badge(G.localization.misc.dictionary.bunc_mysterious_tarot, get_type_colour(self or card.config, card), nil, 1.2)
    end,

    config = {max_highlighted = 3, suit_conv = 'bunc_Fleurons'},
    pos = coordinate_from_atlas_index(1),

    loc_vars = function(self) return {vars = {self.config.max_highlighted}} end,

    use = function(self)
        enable_exotics()

        for i=1, #G.hand.highlighted do
            local percent = 1.15 - (i-0.999)/(#G.hand.highlighted-0.998)*0.3
            event({trigger = 'after', delay = 0.15, func = function()
                G.hand.highlighted[i]:flip();play_sound('card1', percent);G.hand.highlighted[i]:juice_up(0.3, 0.3);
            return true end })
        end
        delay(0.2)
        for i=1, #G.hand.highlighted do
            event({trigger = 'after', delay = 0.1, func = function()
                G.hand.highlighted[i]:change_suit(self.config.suit_conv);
            return true end })
        end
        for i=1, #G.hand.highlighted do
            local percent = 0.85 + ( i - 0.999 ) / ( #G.hand.highlighted - 0.998 ) * 0.3
            event({trigger = 'after', delay = 0.15, func = function()
                G.hand.highlighted[i]:flip(); play_sound('tarot2', percent, 0.6); G.hand.highlighted[i]:juice_up(0.3, 0.3);
            return true end })
        end
        event({trigger = 'after', delay = 0.2, func = function()
            G.hand:unhighlight_all();
        return true end })
        delay(0.5)
    end,

    in_pool = BUNCOMOD.funcs.exotic_in_pool
}

SMODS.Consumable{ -- The Abyss
    set = 'Tarot', atlas = 'bunco_tarots_exotic',
    key = 'abyss',
    set_card_type_badge = function(self, card, badges)
        badges[1] = create_badge(G.localization.misc.dictionary.bunc_mysterious_tarot, get_type_colour(self or card.config, card), nil, 1.2)
    end,

    config = {max_highlighted = 3, suit_conv = 'bunc_Halberds'},
    pos = coordinate_from_atlas_index(2),

    loc_vars = function(self) return {vars = {self.config.max_highlighted}} end,

    use = function(self)
        enable_exotics()

        for i=1, #G.hand.highlighted do
            local percent = 1.15 - (i-0.999)/(#G.hand.highlighted-0.998)*0.3
            event({trigger = 'after', delay = 0.15, func = function()
                G.hand.highlighted[i]:flip();play_sound('card1', percent);G.hand.highlighted[i]:juice_up(0.3, 0.3);
            return true end })
        end
        delay(0.2)
        for i=1, #G.hand.highlighted do
            event({trigger = 'after', delay = 0.1, func = function()
                G.hand.highlighted[i]:change_suit(self.config.suit_conv);
            return true end })
        end
        for i=1, #G.hand.highlighted do
            local percent = 0.85 + ( i - 0.999 ) / ( #G.hand.highlighted - 0.998 ) * 0.3
            event({trigger = 'after', delay = 0.15, func = function()
                G.hand.highlighted[i]:flip(); play_sound('tarot2', percent, 0.6); G.hand.highlighted[i]:juice_up(0.3, 0.3);
            return true end })
        end
        event({trigger = 'after', delay = 0.2, func = function()
            G.hand:unhighlight_all();
        return true end })
        delay(0.5)
    end,

    in_pool = BUNCOMOD.funcs.exotic_in_pool
}

-- Planets

SMODS.Atlas({key = 'bunco_planets', path = 'Consumables/Planets.png', px = 71, py = 95})

SMODS.Consumable{ -- Quaoar
    set = 'Planet', atlas = 'bunco_planets',
    key = 'quaoar',
    set_card_type_badge = function(self, card, badges)
        badges[1] = create_badge(config.fixed_badges and localize('k_planet_q') or localize('k_dwarf_planet'), get_type_colour(self or card.config, card), nil, 1.2)
    end,

    config = {hand_type = 'bunc_Spectrum', softlock = true},
    pos = coordinate_from_atlas_index(1),

    generate_ui = 0,
    process_loc_text = function(self)
        local target_text = G.localization.descriptions[self.set]['c_mercury'].text
        SMODS.Consumable.process_loc_text(self)
        G.localization.descriptions[self.set][self.key] = {}
        G.localization.descriptions[self.set][self.key].text = target_text
    end
}

SMODS.Consumable{ -- Haumea
    set = 'Planet', atlas = 'bunco_planets',
    key = 'haumea',
    set_card_type_badge = function(self, card, badges)
        badges[1] = create_badge(config.fixed_badges and localize('k_planet_q') or localize('k_dwarf_planet'), get_type_colour(self or card.config, card), nil, 1.2)
    end,

    config = {hand_type = 'bunc_Straight Spectrum', softlock = true},
    pos = coordinate_from_atlas_index(2),

    generate_ui = 0,
    process_loc_text = function(self)
        local target_text = G.localization.descriptions[self.set]['c_mercury'].text
        SMODS.Consumable.process_loc_text(self)
        G.localization.descriptions[self.set][self.key] = {}
        G.localization.descriptions[self.set][self.key].text = target_text
    end
}

SMODS.Consumable{ -- Sedna
    set = 'Planet', atlas = 'bunco_planets',
    key = 'sedna',
    set_card_type_badge = function(self, card, badges)
        badges[1] = create_badge(config.fixed_badges and localize('k_planet_q') or localize('k_dwarf_planet'), get_type_colour(self or card.config, card), nil, 1.2)
    end,

    config = {hand_type = 'bunc_Spectrum House', softlock = true},
    pos = coordinate_from_atlas_index(3),

    generate_ui = 0,
    process_loc_text = function(self)
        local target_text = G.localization.descriptions[self.set]['c_mercury'].text
        SMODS.Consumable.process_loc_text(self)
        G.localization.descriptions[self.set][self.key] = {}
        G.localization.descriptions[self.set][self.key].text = target_text
    end
}

SMODS.Consumable{ -- Makemake
    set = 'Planet', atlas = 'bunco_planets',
    key = 'makemake',
    set_card_type_badge = function(self, card, badges)
        badges[1] = create_badge(config.fixed_badges and localize('k_planet_q') or localize('k_dwarf_planet'), get_type_colour(self or card.config, card), nil, 1.2)
    end,

    config = {hand_type = 'bunc_Spectrum Five', softlock = true},
    pos = coordinate_from_atlas_index(4),

    generate_ui = 0,
    process_loc_text = function(self)
        local target_text = G.localization.descriptions[self.set]['c_mercury'].text
        SMODS.Consumable.process_loc_text(self)
        G.localization.descriptions[self.set][self.key] = {}
        G.localization.descriptions[self.set][self.key].text = target_text
    end
}

-- Spectrals

SMODS.Atlas({key = 'bunco_spectrals', path = 'Consumables/Spectrals.png', px = 71, py = 95})

SMODS.Consumable{ -- Cleanse
    set = 'Spectral', atlas = 'bunco_spectrals',
    key = 'cleanse',

    config = {max_highlighted = 3},
    pos = coordinate_from_atlas_index(1),

    loc_vars = function(self, info_queue)
        info_queue[#info_queue+1] = G.P_CENTERS.e_bunc_fluorescent
        return {vars = {self.config.max_highlighted}}
    end,

    can_use = function(self, card)
        if G.hand and (#G.hand.highlighted <= self.config.max_highlighted) and G.hand.highlighted[1] then
            local condition = true
            for i = 1, #G.hand.highlighted do
                if G.hand.highlighted[i].edition then
                    condition = false
                end
            end
            if condition then return true end
        end
        return false
    end,

    use = function(self, card)
        local edition = {bunc_fluorescent = true}
        for i = 1, #G.hand.highlighted do
            event({trigger = 'after', delay = 0.1, func = function()
                local highlighted = G.hand.highlighted[i]
                highlighted:set_edition(edition, true)
            return true end })
        end
        card:juice_up(0.3, 0.5)
    end
}

-- Functions for Polyminoes

SMODS.Atlas({key = 'bunco_link', path = 'Links/Link.png', px = 71, py = 95})

function create_polymino_card_set(example)
    local cardarea = CardArea(
        0,
        0,
        2.85 * G.CARD_W,
        0.75 * G.CARD_H,
        {card_limit = 4, type = 'title', highlight_limit = 0}
    )
    for k, v in ipairs(example) do
        local card = Card(
        0,
        0,
        0.5 * G.CARD_W,
        0.5 * G.CARD_H,
        G.P_CARDS[v[1]],
        G.P_CENTERS.c_base)
        if v[2] then card:juice_up(0.3, 0.2) end
        if k == 1 then play_sound('paper1', 0.95 + math.random() * 0.1, 0.3) end
        ease_value(card.T, 'scale', v[2] and 0.25 or -0.15, nil, 'REAL', true, 0.2)
        cardarea:emplace(card)
    end

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

function link_cards(cards, source, ignore_groups)
    G.GAME.last_card_group = (G.GAME.last_card_group or 0) + 1

    for i = 1, #cards do
        local card = cards[i]
        if (not ignore_groups) or (ignore_groups and not card.ability.group) then
            card.ability.group = {id = G.GAME.last_card_group, source = source or 'unknown'}
        end
    end

    G.PROFILES[G.SETTINGS.profile].cards_linked = (G.PROFILES[G.SETTINGS.profile].cards_linked or 0) + 1
    if G.PROFILES[G.SETTINGS.profile].cards_linked then
        check_for_unlock({type = 'link_cards', links_total = G.PROFILES[G.SETTINGS.profile].cards_linked})
    end
end

SMODS.DrawStep({
    key = 'linked_group',
    order = 500,
    func = function(card, layer)
        if card.ability.group and card.area ~= G.deck then
            if not card.children.link then
                local variant = card.ability.group.id
                variant = 1 + (variant - 1) % 5
                card.children.link = Sprite(card.T.x, card.T.y, card.T.w, card.T.h, G.ASSET_ATLAS['bunc_bunco_link'], {x = variant - 1, y = 0})
                card.children.link.states.visible = false
            end
            card.children.link:draw_shader('dissolve', nil, nil, nil, card.children.center, 0, 0)
            card.children.link.role.draw_major = card
        end
    end
})

CardArea.bunc_original_cardarea_emplace = CardArea.emplace
function CardArea:emplace(card, location, stay_flipped)
    local ret = self:bunc_original_cardarea_emplace(card, location, stay_flipped)
    if self == G.hand and card.ability.group and card.ability.group.id then
        event({trigger = 'immediate', func = function()
            local n = 0
            while n < #G.deck.cards do
                local other_card = G.deck.cards[#G.deck.cards - n]

                if other_card == card or other_card.area == G.hand or not other_card then

                else
                    if other_card.ability.group and other_card.ability.group.id == card.ability.group.id and other_card.area == G.deck then
                        event({trigger = 'immediate', func = function()
                            draw_card(G.deck, G.hand, percent, 'up', true, other_card)
                            return true
                        end})
                    end
                end

                n = n + 1
            end

            event({trigger = 'immediate', func = function()
                SMODS.calculate_context({bunc_groups_drawn = {card.ability.group.id}})
                return true
            end})
            return true 
        end})
    end
    return ret
end

local bunc_original_add_to_highlighted = CardArea.add_to_highlighted
function CardArea:add_to_highlighted(card, silent)
    if G.STATE ~= G.STATES.DRAW_TO_HAND and not G.DRAWING_CARDS then
        local original_highlited_limit = self.config.highlighted_limit
        self.config.highlighted_limit = G.GAME.THE_8_BYPASS and self.config.type == "hand" and math.huge or self.config.highlighted_limit

        if card.ability.group and self then
            local 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 self.config.type == 'hand' and not self.cards[i].highlighted and not (card ~= self.cards[i] and self.cards[i].edition and self.cards[i].edition.bunc_fluorescent) then
                        table.insert(group, self.cards[i])
                    end
                end
            end
            for i = 1, #group do
                if i ~= #group then
                    self.highlighted[#self.highlighted+1] = group[i]
                    group[i].highlighted = true

                    -- The Gate fix

                    if G.GAME.blind and G.GAME.blind.name == 'bl_bunc_gate' and not G.GAME.blind.disabled and self == G.hand then
                        group[i].ability.forced_selection = true
                    end

                else
                    bunc_original_add_to_highlighted(self, group[i], (silent == nil) and false or silent)
                end
            end
        else
            bunc_original_add_to_highlighted(self, card, silent)
        end

        self.config.highlighted_limit = original_highlited_limit
    end
end

local bunc_original_remove_from_highlighted = CardArea.remove_from_highlighted
function CardArea:remove_from_highlighted(card, force)
    if card.ability.group and self and not force then
        local group = {}
        for i = 1, #self.cards do
            if self.config.type == 'hand'
            and self.cards[i].ability.group
            and self.cards[i].ability.group.id == card.ability.group.id then
                table.insert(group, self.cards[i])
            end
        end
        for i = 1, #group do
            for index, highligthed in ipairs(self.highlighted) do
                if highligthed == group[i] then
                    table.remove(self.highlighted, index)
                end
            end
            group[i].highlighted = false
            if i == #group then
                bunc_original_remove_from_highlighted(self, group[i], force)
            end
        end
    else
        bunc_original_remove_from_highlighted(self, card, force)
    end
end

-- Allows for a group of over 5 cards to be played/discarded
local bunc_original_G_FUNCS_can_play = G.FUNCS.can_play
G.FUNCS.can_play = function(e)
    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

    local original_play_limit = G.GAME.starting_params.play_limit
    
    G.GAME.starting_params.play_limit = math.max(G.GAME.starting_params.play_limit, group_size)

    local ret = bunc_original_G_FUNCS_can_play(e)

    G.GAME.starting_params.play_limit = original_play_limit

    return ret
end
local bunc_original_G_FUNCS_can_discard = G.FUNCS.can_discard
G.FUNCS.can_discard = function(e)
    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

    local original_discard_limit = G.GAME.starting_params.discard_limit
    
    G.GAME.starting_params.discard_limit = math.max(G.GAME.starting_params.discard_limit, group_size)

    local ret = bunc_original_G_FUNCS_can_discard(e)

    G.GAME.starting_params.discard_limit = original_discard_limit

    return ret
end

-- Polyminoes

SMODS.Atlas({key = 'bunco_polyminoes_undiscovered', path = 'Consumables/PolyminoesUndiscovered.png', px = 71, py = 95})
SMODS.Atlas({key = 'bunco_polyminoes', path = 'Consumables/Polyminoes.png', px = 71, py = 95})

SMODS.ConsumableType{
    key = 'Polymino',
    primary_colour = HEX('424e54'),
    secondary_colour = HEX('4fb66f'),
    collection_rows = {4, 4}
}

SMODS.UndiscoveredSprite{
    key = 'Polymino',
    atlas = 'bunco_polyminoes_undiscovered',
    pos = coordinate_from_atlas_index(1)
}

SMODS.Consumable{ -- The I
    set = 'Polymino', atlas = 'bunco_polyminoes',
    key = 'the_i',

    loc_vars = function(self, info_queue, card)

        info_queue[#info_queue+1] = {set = 'Other', key = 'bunc_linked_group'}

        local example = {
            {'S_2', true},
            {'S_6', true},
            {'S_7', true},
            {'S_Q', true}
        }
        return {main_end = {create_polymino_card_set(example)}}
    end,

    can_use = function(self, card)
        if G.hand and (#G.hand.highlighted == 4 or (G.GAME.used_vouchers['v_bunc_polybius'] and #G.hand.highlighted == 5)) then
            local cards = G.hand.highlighted

            -- Group check:

            for i = 1, #cards do
                if cards[i].ability.group then return false end
            end

            -- Suit check:

            for i = 1, #SMODS.Suit.obj_buffer do
                local suit = SMODS.Suit.obj_buffer[i]
                local same_suit = 0
                for j = 1, #cards do
                    if cards[j]:is_suit(suit, nil, true) then
                        same_suit = same_suit + 1
                    end
                end
                if same_suit >= 4 then return true end
            end

            -- Rank check:

            for i = 1, #cards do
                local rank = cards[i]:get_id()
                local same_rank = 0
                for j = 1, #cards do
                    if cards[j]:get_id() == rank then
                        same_rank = same_rank + 1
                    end
                end
                if same_rank >= 4 then return true end
            end
        end
        return false
    end,

    use = function(self, card)
        link_cards(G.hand.highlighted, self.key)
        card:juice_up(0.3, 0.5)
    end,

    pos = coordinate_from_atlas_index(1),
}

SMODS.Consumable{ -- The O
    set = 'Polymino', atlas = 'bunco_polyminoes',
    key = 'the_o',

    loc_vars = function(self, info_queue, card)

        info_queue[#info_queue+1] = {set = 'Other', key = 'bunc_linked_group'}

        local example = {
            {'D_Q', true},
            {'D_Q', true},
            {'H_K', true},
            {'C_K', true}
        }
        return {main_end = {create_polymino_card_set(example)}}
    end,

    can_use = function(self, card)
        if G.hand and (#G.hand.highlighted == 4 or (G.GAME.used_vouchers['v_bunc_polybius'] and #G.hand.highlighted == 5)) then
            local cards = G.hand.highlighted

            -- Group check:

            for i = 1, #cards do
                if cards[i].ability.group then return false end
            end

            -- Count occurrences of each suit and rank

            local suit_count = {}
            local rank_count = {}

            for i = 1, #cards do
                for j = 1, #SMODS.Suit.obj_buffer do
                    local suit = SMODS.Suit.obj_buffer[j]
                    if cards[i]:is_suit(suit, nil, true) then
                        suit_count[suit] = (suit_count[suit] or 0) + 1
                    end
                end

                local rank = cards[i]:get_id()
                rank_count[rank] = (rank_count[rank] or 0) + 1
            end

            -- Check for exactly two cards with the same suit

            local matching_suits = 0
            local matching_ranks = 0

            for _, count in pairs(suit_count) do
                if count >= 2 then
                    matching_suits = matching_suits + 1
                end
            end

            -- Check for exactly two cards with the same rank

            for _, count in pairs(rank_count) do
                if count >= 2 then
                    matching_ranks = matching_ranks + 1
                end
            end

            -- Check for two matches of either rank or suit

            if matching_suits >= 2 or matching_ranks >= 2 then
                return true
            end
        end
        return false
    end,

    use = function(self, card)
        link_cards(G.hand.highlighted, self.key)
        card:juice_up(0.3, 0.5)
    end,

    pos = coordinate_from_atlas_index(2),
}

SMODS.Consumable{ -- The T
    set = 'Polymino', atlas = 'bunco_polyminoes',
    key = 'the_t',

    loc_vars = function(self, info_queue, card)

        info_queue[#info_queue+1] = {set = 'Other', key = 'bunc_linked_group'}

        local example = {
            {'H_7', true},
            {'C_7', true},
            {'S_7', true},
            {'H_A', true}
        }
        return {main_end = {create_polymino_card_set(example)}}
    end,

    can_use = function(self, card)
        if G.hand and (#G.hand.highlighted == 4 or (G.GAME.used_vouchers['v_bunc_polybius'] and #G.hand.highlighted == 5)) then
            local cards = G.hand.highlighted

            -- Group check:

            for i = 1, #cards do
                if cards[i].ability.group then return false end
            end

            -- Count occurrences of each suit and rank

            local suit_count = {}
            local rank_count = {}

            for i = 1, #cards do
                for j = 1, #SMODS.Suit.obj_buffer do
                    local suit = SMODS.Suit.obj_buffer[j]
                    if cards[i]:is_suit(suit, nil, true) then
                        suit_count[suit] = (suit_count[suit] or 0) + 1
                    end
                end

                local rank = cards[i]:get_id()
                rank_count[rank] = (rank_count[rank] or 0) + 1
            end


            local matching_suits = 0
            local matching_ranks = 0
            local mismatched_suits = 0
            local mismatched_ranks = 0

            -- Check for exactly three cards with the same suit

            for _, count in pairs(suit_count) do
                if count >= 3 then
                    matching_suits = matching_suits + 1
                elseif count >= 1 then
                    mismatched_suits = mismatched_suits + 1
                end
            end

            -- Check for exactly three cards with the same rank

            for _, count in pairs(rank_count) do
                if count >= 3 then
                    matching_ranks = matching_ranks + 1
                elseif count >= 1 then
                    mismatched_ranks = mismatched_ranks + 1
                end
            end

            -- Check for three matches of either rank or suit and one mismatch

            say('matching_ranks: '..matching_ranks..', mismatched_ranks: '..mismatched_ranks)
            say('matching_suits: '..matching_suits..', mismatched_suits: '..mismatched_suits)

            if (matching_suits >= 1 and mismatched_suits >= 1) or (matching_ranks >= 1 and mismatched_ranks >= 1) then
                return true
            end
        end
        return false
    end,

    use = function(self, card)
        link_cards(G.hand.highlighted, self.key)
        card:juice_up(0.3, 0.5)
    end,

    pos = coordinate_from_atlas_index(3),
}

SMODS.Consumable{ -- The S
    set = 'Polymino', atlas = 'bunco_polyminoes',
    key = 'the_s',

    loc_vars = function(self, info_queue, card)

        info_queue[#info_queue+1] = {set = 'Other', key = 'bunc_linked_group'}

        local example = {
            {'D_2', true},
            {'C_2', true},
            {'C_T', true},
            {'S_T', true}
        }
        return {main_end = {create_polymino_card_set(example)}}
    end,

    can_use = function(self, card)
        if G.hand and (#G.hand.highlighted == 4 or (G.GAME.used_vouchers['v_bunc_polybius'] and #G.hand.highlighted == 5)) then
            local cards = G.hand.highlighted

            -- Group check:

            for i = 1, #cards do
                if cards[i].ability.group then return false end
            end

            -- Count occurrences of each rank and suit

            local suit_count = {}
            local rank_count = {}

            for i = 1, #cards do
                for j = 1, #SMODS.Suit.obj_buffer do
                    local suit = SMODS.Suit.obj_buffer[j]
                    if cards[i]:is_suit(suit, nil, true) then
                        suit_count[suit] = (suit_count[suit] or 0) + 1
                    end
                end

                local rank = cards[i]:get_id()
                rank_count[rank] = rank_count[rank] or {}
                table.insert(rank_count[rank], cards[i])
            end

            -- Identify two groups of two cards with the same rank

            local pair1, pair2 = nil, nil
            for rank, cards in pairs(rank_count) do
                if #cards >= 2 then
                    if not pair1 then
                        pair1 = cards
                    elseif not pair2 then
                        pair2 = cards
                        break
                    end
                end
            end

            if not pair1 or not pair2 then
                return false
            end

            -- Check for a common suit between the pairs

            local shared_suits = {}
            for _, card1 in ipairs(pair1) do
                for _, card2 in ipairs(pair2) do
                    for j = 1, #SMODS.Suit.obj_buffer do
                        local suit = SMODS.Suit.obj_buffer[j]
                        if card1:is_suit(suit, nil, true) and card2:is_suit(suit, nil, true) then
                            shared_suits[suit] = true
                        end
                    end
                end
            end

            if next(shared_suits) then
                return true
            end
        end
        return false
    end,

    use = function(self, card)
        link_cards(G.hand.highlighted, self.key)
        card:juice_up(0.3, 0.5)
    end,

    pos = coordinate_from_atlas_index(4),
}

SMODS.Consumable{ -- The Z
    set = 'Polymino', atlas = 'bunco_polyminoes',
    key = 'the_z',

    loc_vars = function(self, info_queue, card)

        info_queue[#info_queue+1] = {set = 'Other', key = 'bunc_linked_group'}

        local example = {
            {'S_4', true},
            {'S_A', true},
            {'H_A', true},
            {'H_J', true}
        }
        return {main_end = {create_polymino_card_set(example)}}
    end,

    can_use = function(self, card)
        if G.hand and (#G.hand.highlighted == 4 or (G.GAME.used_vouchers['v_bunc_polybius'] and #G.hand.highlighted == 5)) then
            local cards = G.hand.highlighted

            -- Group check:

            for i = 1, #cards do
                if cards[i].ability.group then return false end
            end

            -- Count occurrences of each suit and rank

            local suit_count = {}
            local rank_count = {}

            for i = 1, #cards do
                for j = 1, #SMODS.Suit.obj_buffer do
                    local suit = SMODS.Suit.obj_buffer[j]
                    if cards[i]:is_suit(suit, nil, true) then
                        suit_count[suit] = suit_count[suit] or {}
                        table.insert(suit_count[suit], cards[i])
                    end
                end

                local rank = cards[i]:get_id()
                rank_count[rank] = (rank_count[rank] or 0) + 1
            end

            -- Identify two groups of two cards with the same suit

            local pair1, pair2 = nil, nil
            for suit, cards in pairs(suit_count) do
                if #cards >= 2 then
                    if not pair1 then
                        pair1 = cards
                    elseif not pair2 then
                        pair2 = cards
                        break
                    end
                end
            end

            if not pair1 or not pair2 then
                return false
            end

            -- Check for a common rank between the pairs

            local shared_ranks = {}
            for _, card1 in ipairs(pair1) do
                for _, card2 in ipairs(pair2) do
                    if card1:get_id() == card2:get_id() then
                        shared_ranks[card1:get_id()] = true
                    end
                end
            end

            if next(shared_ranks) then
                return true
            end
        end
        return false
    end,

    use = function(self, card)
        link_cards(G.hand.highlighted, self.key)
        card:juice_up(0.3, 0.5)
    end,

    pos = coordinate_from_atlas_index(5),
}

SMODS.Consumable{ -- The J
    set = 'Polymino', atlas = 'bunco_polyminoes',
    key = 'the_j',

    loc_vars = function(self, info_queue, card)

        info_queue[#info_queue+1] = {set = 'Other', key = 'bunc_linked_group'}

        local example = {
            {'D_Q', true},
            {'H_Q', true},
            {'C_Q', true},
            {'C_K', true}
        }
        return {main_end = {create_polymino_card_set(example)}}
    end,

    can_use = function(self, card)
        if G.hand and (#G.hand.highlighted == 4 or (G.GAME.used_vouchers['v_bunc_polybius'] and #G.hand.highlighted == 5)) then
            local cards = G.hand.highlighted

            -- Group check:

            for i = 1, #cards do
                if cards[i].ability.group then return false end
            end

           -- Count occurrences of each rank and suit

            local suit_count = {}
            local rank_count = {}

            for i = 1, #cards do
                for j = 1, #SMODS.Suit.obj_buffer do
                    local suit = SMODS.Suit.obj_buffer[j]
                    if cards[i]:is_suit(suit, nil, true) then
                        suit_count[suit] = suit_count[suit] or {}
                        table.insert(suit_count[suit], cards[i])
                    end
                end

                local rank = cards[i]:get_id()
                rank_count[rank] = rank_count[rank] or {}
                table.insert(rank_count[rank], cards[i])
            end

            -- Identify three cards with the same rank

            local three_of_a_kind = nil
            local other_cards = nil

            for rank, cards in pairs(rank_count) do
                if #cards >= 3 then
                    three_of_a_kind = cards
                elseif #cards >= 1 then
                    if not other_cards then
                        other_cards = {}
                    end
                    for _, card in ipairs(cards) do
                        table.insert(other_cards, card)
                    end
                end
            end

            if not three_of_a_kind or not other_cards then
                return false
            end

            -- Check for a common suit between the three cards and the other card

            local common_suit_found = false
            for j = 1, #SMODS.Suit.obj_buffer do
                local suit = SMODS.Suit.obj_buffer[j]
                for _, other_card in ipairs(other_cards) do
                    if other_card:is_suit(suit, nil, true) then
                        for _, card in ipairs(three_of_a_kind) do
                            if card:is_suit(suit, nil, true) then
                                common_suit_found = true
                            end
                        end
                    end
                end
                if common_suit_found then
                    break
                end
            end

            if common_suit_found then
                return true
            end
        end
        return false
    end,

    use = function(self, card)
        link_cards(G.hand.highlighted, self.key)
        card:juice_up(0.3, 0.5)
    end,

    pos = coordinate_from_atlas_index(6),
}

SMODS.Consumable{ -- The L
    set = 'Polymino', atlas = 'bunco_polyminoes',
    key = 'the_l',

    loc_vars = function(self, info_queue, card)

        info_queue[#info_queue+1] = {set = 'Other', key = 'bunc_linked_group'}

        local example = {
            {'S_2', true},
            {'S_3', true},
            {'S_T', true},
            {'D_T', true}
        }
        return {main_end = {create_polymino_card_set(example)}}
    end,

    can_use = function(self, card)
        if G.hand and (#G.hand.highlighted == 4 or (G.GAME.used_vouchers['v_bunc_polybius'] and #G.hand.highlighted == 5)) then
            local cards = G.hand.highlighted

            -- Group check:

            for i = 1, #cards do
                if cards[i].ability.group then return false end
            end

           -- Count occurrences of each suit and rank

            local suit_count = {}
            local rank_count = {}

            for i = 1, #cards do
                for j = 1, #SMODS.Suit.obj_buffer do
                    local suit = SMODS.Suit.obj_buffer[j]
                    if cards[i]:is_suit(suit, nil, true) then
                        suit_count[suit] = suit_count[suit] or {}
                        table.insert(suit_count[suit], cards[i])
                    end
                end

                local rank = cards[i]:get_id()
                rank_count[rank] = rank_count[rank] or {}
                table.insert(rank_count[rank], cards[i])
            end

            -- Identify three cards with the same suit

            local three_of_a_suit = nil
            local other_cards = nil

            for suit, cards in pairs(suit_count) do
                if #cards >= 3 then
                    three_of_a_suit = cards
                elseif #cards >= 1 then
                    if not other_cards then
                        other_cards = {}
                    end
                    for _, card in ipairs(cards) do
                        table.insert(other_cards, card)
                    end
                end
            end

            if not three_of_a_suit or not other_cards then
                return false
            end

            -- Check for a common rank between the three cards and the other card

            local common_rank_found = false

            for _, other_card in ipairs(other_cards) do
                local other_card_rank = other_card:get_id()

                for _, card in ipairs(three_of_a_suit) do
                    if card:get_id() == other_card_rank then
                        common_rank_found = true
                        break
                    end
                end
            end

            if common_rank_found then
                return true
            end
        end
        return false
    end,

    use = function(self, card)
        link_cards(G.hand.highlighted, self.key)
        card:juice_up(0.3, 0.5)
    end,

    pos = coordinate_from_atlas_index(7),
}

SMODS.Consumable{ -- The /
    set = 'Polymino', atlas = 'bunco_polyminoes',
    key = 'the_slash',

    loc_vars = function(self, info_queue, card)

        info_queue[#info_queue+1] = {set = 'Other', key = 'bunc_linked_group'}

        local example = {
            {'S_2', true},
            {'C_T', true},
            {'H_Q', true},
            {'D_A', true}
        }
        return {main_end = {create_polymino_card_set(example)}}
    end,

    set_card_type_badge = function(self, card, badges)
        badges[1] = create_badge(G.localization.misc.dictionary.bunc_mysterious_polymino, get_type_colour(self or card.config, card), nil, 1.2)
    end,

    can_use = function(self, card)
        if G.hand and (#G.hand.highlighted == 4 or (G.GAME.used_vouchers['v_bunc_polybius'] and #G.hand.highlighted == 5)) then
            local cards = G.hand.highlighted

            -- Group check:

            for i = 1, #cards do
                if cards[i].ability.group then return false end
            end

           -- Track unique ranks and suits

            local rank_set = {}
            local suit_set = {}

            local extra_suits = 0
            local extra_ranks = 0

            for i = 1, #cards do
                local rank = cards[i]:get_id()

                -- Collect all suits the card belongs to

                local card_suits = {}
                for j = 1, #SMODS.Suit.obj_buffer do
                    local suit = SMODS.Suit.obj_buffer[j]
                    if cards[i]:is_suit(suit, nil, true) then
                        table.insert(card_suits, suit)
                    end
                end

                -- Check if rank or suit is already in the set

                if rank_set[rank] then
                    extra_ranks = extra_ranks + 1
                end

                if (#cards == 4 and extra_ranks >= 1) or (#cards == 5 and extra_ranks >= 2) then
                    return false
                end

                for _, suit in ipairs(card_suits) do
                    if suit_set[suit] then
                        extra_suits = extra_suits + 1
                    end
                end

                if (#cards == 4 and extra_suits >= 1) or (#cards == 5 and extra_suits >= 2) then
                    return false
                end

                -- Add rank and suits to their respective sets

                rank_set[rank] = true
                for _, suit in ipairs(card_suits) do
                    suit_set[suit] = true
                end
            end

            return true
        end
        return false
    end,

    use = function(self, card)
        link_cards(G.hand.highlighted, self.key)
        card:juice_up(0.3, 0.5)
    end,

    pos = coordinate_from_atlas_index(8),

    in_pool = function(self)
        return BUNCOMOD.funcs.exotic_in_pool()
    end
}

SMODS.Consumable{ -- The 8
    set = 'Spectral', atlas = 'bunco_polyminoes',
    key = 'the_8',

    loc_vars = function(self, info_queue, card)
        info_queue[#info_queue+1] = {set = 'Other', key = 'bunc_linked_group'}
    end,

    hidden = true,
    soul_rate = 0.002,
    soul_set = 'Polymino',

    update = function(self, card)
        if card.highlighted then
            if G.GAME then G.GAME.THE_8_BYPASS = true end
        end
    end,

    can_use = function(self, card)
        local cards = G.hand.highlighted

        -- Group check:

        for i = 1, #cards do
            if cards[i].ability.group then return false end
        end

        if #cards > 1 then
            return true
        end
        return false
    end,

    use = function(self, card)
        link_cards(G.hand.highlighted, self.key)
        card:juice_up(0.3, 0.5)
    end,

    pos = coordinate_from_atlas_index(9),
}

-- Exotic suits

SMODS.Atlas({key = 'bunco_cards', path = 'Exotic/ExoticCards.png', px = 71, py = 95})
SMODS.Atlas({key = 'bunco_cards_hc', path = 'Exotic/ExoticCardsHC.png', px = 71, py = 95})

SMODS.Atlas({key = 'bunco_suits', path = 'Exotic/ExoticSuits.png', px = 18, py = 18})
SMODS.Atlas({key = 'bunco_suits_hc', path = 'Exotic/ExoticSuitsHC.png', px = 18, py = 18})

SMODS.Suit{ -- Fleurons
    key = 'Fleurons',
    card_key = 'FLEURON',
    hidden = true,

    lc_atlas = 'bunco_cards',
    hc_atlas = 'bunco_cards_hc',

    lc_ui_atlas = 'bunco_suits',
    hc_ui_atlas = 'bunco_suits_hc',

    pos = { x = 0, y = 0 },
    ui_pos = { x = 0, y = 0 },

    lc_colour = HEX('d6901a'),
    hc_colour = HEX('dbb529'),

    in_pool = function(self, args)
        if args and args.initial_deck then
            return false
        end
        return BUNCOMOD.funcs.exotic_in_pool()
    end
}

SMODS.Suit{ -- Halberds
    key = 'Halberds',
    card_key = 'HALBERD',
    hidden = true,

    lc_atlas = 'bunco_cards',
    hc_atlas = 'bunco_cards_hc',

    lc_ui_atlas = 'bunco_suits',
    hc_ui_atlas = 'bunco_suits_hc',

    pos = { x = 0, y = 1 },
    ui_pos = { x = 1, y = 0 },

    lc_colour = HEX('6e3c63'),
    hc_colour = HEX('993283'),

    in_pool = function(self, args)
        if args and args.initial_deck then
            return false
        end
        return BUNCOMOD.funcs.exotic_in_pool()
    end
}

table.insert(SMODS.Suit.obj_buffer, 1, table.remove(SMODS.Suit.obj_buffer, #SMODS.Suit.obj_buffer)) -- Sort suits
table.insert(SMODS.Suit.obj_buffer, 1, table.remove(SMODS.Suit.obj_buffer, #SMODS.Suit.obj_buffer))
table.insert(SMODS.Suit.obj_buffer, 1, table.remove(SMODS.Suit.obj_buffer, 2))

-- Skins and deck resprites

SMODS.Atlas{key = 'bunco_resprites_enhanced_contrast', path = 'Resprites/EnhancedContrast.png', px = 71, py = 95}
SMODS.Atlas{key = 'bunco_resprites_enhanced_contrast_ui', path = 'Resprites/EnhancedUIContrast.png', px = 18, py = 18}
SMODS.Atlas{key = 'bunco_paperback_enhanced_contrast', path = 'Resprites/EnhancedContrastPaperback.png', px = 71, py = 95}

-- Bunco High Contrast

local collabs = {
    Hearts = {'AU', 'TBoI', 'CL', 'D2', 'BUG', 'CR'},
    Diamonds = {'DTD', 'SV', 'EG', 'XR', 'C7', 'R'},
    Clubs = {'VS', 'STS', 'PC', 'WF', 'DBD', 'FO'},
    Spades = {'TW', 'CYP', 'SK', 'DS', 'AC', 'STP'},
}

local bunc_hc_colours = {
    Hearts = HEX('ee151b'),
    Diamonds = HEX('e56b10'),
    Spades = HEX('5d55a6'),
    Clubs = HEX('197f77')
}

for i, suit in ipairs({'Hearts', 'Diamonds', 'Clubs', 'Spades'}) do
    SMODS.DeckSkin.add_palette(SMODS.DeckSkins['default_' .. suit], {
        key = 'recast_contrast',
        ranks = {'2', '3', '4', '5', '6', '7', '8', '9', '10', 'Jack', 'Queen', 'King', 'Ace', 'paperback_Apostle'},
        display_ranks = {'King', 'Queen', 'Jack'},
        atlas = 'bunc_bunco_resprites_enhanced_contrast',
        pos_style = {
            fallback_style = "deck",
            ['paperback_Apostle'] = { pos = {x = 0, y = ({0, 2, 1, 3})[i]}, atlas = 'bunc_bunco_paperback_enhanced_contrast'},
        },
        colour = bunc_hc_colours[suit],
        suit_icon = {
            atlas = 'bunc_bunco_resprites_enhanced_contrast_ui',
            pos = {x = i - 1, y = 0}
        },
    })

    for _, collab in pairs(collabs[suit]) do
        SMODS.Atlas{key = 'collab_'.. collab ..'_alt_hc', path = 'Resprites/collabs/collab_' .. collab .. '_EnhancedContrast.png', px = 71, py = 95}
        SMODS.DeckSkin.add_palette(SMODS.DeckSkins['collab_' .. collab], {
            key = 'recast_contrast',
            ranks = {'2', '3', '4', '5', '6', '7', '8', '9', '10', 'Jack', 'Queen', 'King', 'Ace', 'paperback_Apostle'},
            display_ranks = {'King', 'Queen', 'Jack'},
            atlas = 'bunc_bunco_resprites_enhanced_contrast',
            pos_style = {
                fallback_style = "deck",
                ['paperback_Apostle'] = { pos = {x = 0, y = ({0, 2, 1, 3})[i]}, atlas = 'bunc_bunco_paperback_enhanced_contrast'},
                ['Jack'] = { pos = {x = 0, y = 0}, atlas = 'bunc_collab_'.. collab ..'_alt_hc'},
                ['Queen'] = { pos = {x = 1, y = 0}, atlas = 'bunc_collab_'.. collab ..'_alt_hc'},
                ['King'] = { pos = {x = 2, y = 0}, atlas = 'bunc_collab_'.. collab ..'_alt_hc'},
            },
            colour = bunc_hc_colours[suit],
            suit_icon = {
                atlas = 'bunc_bunco_resprites_enhanced_contrast_ui',
                pos = {x = i - 1, y = 0}
            },
        })
    end
end

SMODS.Atlas({key = 'bunco_skins_duckgame_lc', path = 'Skins/SkinDuckGameLC.png', px = 71, py = 95})
SMODS.Atlas({key = 'bunco_skins_duckgame_hc', path = 'Skins/SkinDuckGameHC.png', px = 71, py = 95})
SMODS.Atlas({key = 'bunco_skins_lisa_the_painful_lc', path = 'Skins/SkinLISAThePainfulLC.png', px = 71, py = 95})
SMODS.Atlas({key = 'bunco_skins_lisa_the_painful_hc', path = 'Skins/SkinLISAThePainfulHC.png', px = 71, py = 95})
SMODS.Atlas({key = 'bunco_skins_fiend_folio_lc', path = 'Skins/SkinFiendFolioLC.png', px = 71, py = 95})
SMODS.Atlas({key = 'bunco_skins_fiend_folio_hc', path = 'Skins/SkinFiendFolioHC.png', px = 71, py = 95})
SMODS.Atlas({key = 'bunco_skins_lisa_the_pointless_lc', path = 'Skins/SkinLISAThePointlessLC.png', px = 71, py = 95})
SMODS.Atlas({key = 'bunco_skins_lisa_the_pointless_hc', path = 'Skins/SkinLISAThePointlessHC.png', px = 71, py = 95})

SMODS.DeckSkin{
    key = 'duck_game',
    suit = 'bunc_Fleurons',
    palettes = {
        {
            key = 'lc',
            ranks = {'Jack', 'Queen', 'King'},
            display_ranks = {'King', 'Queen', 'Jack'},
            pos_style = 'ranks',
            atlas = 'bunc_bunco_skins_duckgame_lc'
        },
        {
            key = 'hc',
            ranks = {'Jack', 'Queen', 'King'},
            display_ranks = {'King', 'Queen', 'Jack'},
            pos_style = 'ranks',
            atlas = 'bunc_bunco_skins_duckgame_hc'
        }
    }
}

SMODS.DeckSkin{
    key = 'lisa_the_painful',
    suit = 'bunc_Fleurons',
    palettes = {
        {
            key = 'lc',
            ranks = {'Jack', 'Queen', 'King'},
            display_ranks = {'King', 'Queen', 'Jack'},
            pos_style = 'ranks',
            atlas = 'bunc_bunco_skins_lisa_the_painful_lc'
        },
        {
            key = 'hc',
            ranks = {'Jack', 'Queen', 'King'},
            display_ranks = {'King', 'Queen', 'Jack'},
            pos_style = 'ranks',
            atlas = 'bunc_bunco_skins_lisa_the_painful_hc'
        }
    }
}

SMODS.DeckSkin{
    key = 'fiend_folio',
    suit = 'bunc_Halberds',
    palettes = {
        {
            key = 'lc',
            ranks = {'Jack', 'Queen', 'King'},
            display_ranks = {'King', 'Queen', 'Jack'},
            pos_style = 'ranks',
            atlas = 'bunc_bunco_skins_fiend_folio_lc'
        },
        {
            key = 'hc',
            ranks = {'Jack', 'Queen', 'King'},
            display_ranks = {'King', 'Queen', 'Jack'},
            pos_style = 'ranks',
            atlas = 'bunc_bunco_skins_fiend_folio_hc'
        }
    }
}

SMODS.DeckSkin{
    key = 'lisa_the_pointless',
    suit = 'bunc_Halberds',
    palettes = {
        {
            key = 'lc',
            ranks = {'Jack', 'Queen', 'King'},
            display_ranks = {'King', 'Queen', 'Jack'},
            pos_style = 'ranks',
            atlas = 'bunc_bunco_skins_lisa_the_pointless_lc'
        },
        {
            key = 'hc',
            ranks = {'Jack', 'Queen', 'King'},
            display_ranks = {'King', 'Queen', 'Jack'},
            pos_style = 'ranks',
            atlas = 'bunc_bunco_skins_lisa_the_pointless_hc'
        }
    }
}

-- Exotic system toggle logic

function disable_exotics()
    if G.GAME then G.GAME.Exotic = false end
    -- say('Triggered Exotic System disabling.')
end

function enable_exotics()
    if G.GAME then G.GAME.Exotic = true end
    -- say('Triggered Exotic System enabling.')
end

-- Poker hands

SMODS.PokerHandPart{ -- Spectrum base (Referenced from SixSuits)
    key = 'spectrum',
    func = function(hand)
        local suits = {}

        -- determine suits to be used
        for _, v in ipairs(SMODS.Suit.obj_buffer) do
            suits[v] = 1
        end
        -- < 5 hand cant be a spectrum
        if #hand < 5 then return {} end

        local extraCardsAllowed = #hand - 5
        local nonwilds = {}
        for i = 1, #hand do
            local cardsuits = {}
            for _, v in ipairs(SMODS.Suit.obj_buffer) do
                -- determine table of suits for each card (for future faster calculations)
                if hand[i]:is_suit(v, nil, true) then
                    table.insert(cardsuits, v)
                end
            end

            -- a card with no suit can't contribute to a spectrum
            if #cardsuits == 0 then
                if extraCardsAllowed <= 0 then return {} end
                extraCardsAllowed = extraCardsAllowed - 1
            -- if only 1 suit: can be handled immediately
            elseif #cardsuits == 1 then
                -- if suit is already present, this card isn't contributing; otherwise remove suit from "not yet used suits"
                if suits[cardsuits[1]] == 0 then
                    if extraCardsAllowed <= 0 then return {} end
                    extraCardsAllowed = extraCardsAllowed - 1
                end
                suits[cardsuits[1]] = 0
            -- add all cards with 2-4 suits to a table to be looked at
            elseif #cardsuits < 5 then
                table.insert(nonwilds, cardsuits)
            end
        end

        -- recursive function for iterating over combinations
        local isSpectrum 
        isSpectrum = function(i, remaining)
            -- traversed all the cards, found spectrum
            if i == #nonwilds + 1 then
                return true
            end

            -- copy remaining suits
            local newremaining = {}
            for k, v in pairs(remaining) do
                newremaining[k] = v
            end

            -- for every suit of the current card: 
            for _, suit in ipairs(nonwilds[i]) do
                -- do nothing if suit has already been used
                if remaining[suit] == 1 then
                    -- use up suit on this card and check next card
                    newremaining[suit] = 0
                    if isSpectrum(i + 1, newremaining) then
                        return true
                    end
                    -- reset suit before continuing
                    newremaining[suit] = 1
                end
            end

            return false
        end

        -- begin iteration from first (not already considered) card
        if isSpectrum(1, suits) then
            return {hand}
        else
            return {}
        end
    end
}

SMODS.PokerHand{ -- Spectrum (Referenced from SixSuits)
    key = 'Spectrum',
    visible = false,
    chips = 50,
    mult = 6,
    l_chips = 20,
    l_mult = 2,
    example = {
        { 'S_2',    true },
        { 'D_7',    true },
        { 'C_3', true },
        { 'bunc_FLEURON_5', true },
        { 'H_K',    true },
    },
    evaluate = function(parts)
        return parts.bunc_spectrum
    end
}

SMODS.PokerHand{ -- Straight Spectrum (Referenced from SixSuits)
    key = 'Straight Spectrum',
    visible = false,
    chips = 120,
    mult = 10,
    l_chips = 45,
    l_mult = 4,
    example = {
        { 'S_Q',    true },
        { 'bunc_FLEURON_J', true },
        { 'C_T',    true },
        { 'D_9', true },
        { 'H_8',    true }
    },
    process_loc_text = function(self)
        SMODS.PokerHand.process_loc_text(self)
        SMODS.process_loc_text(G.localization.misc.poker_hands, self.key..' (Royal)', self.loc_txt, 'extra')
    end,
    evaluate = function(parts)
        if not next(parts.bunc_spectrum) or not next(parts._straight) then return {} end
        return { SMODS.merge_lists (parts.bunc_spectrum, parts._straight) }
    end,
    modify_display_text = function(self, _cards, scoring_hand)
        local royal = true
		for j = 1, #scoring_hand do
			local rank = SMODS.Ranks[scoring_hand[j].base.value]
			royal = royal and (rank.key == 'Ace' or rank.key == '10' or rank.face)
		end
		if royal then
			return self.key..' (Royal)'
		end
    end
}

SMODS.PokerHand{ -- Spectrum House (Referenced from SixSuits)
    key = 'Spectrum House',
    above_hand = 'Flush House',
    visible = false,
    chips = 150,
    mult = 15,
    l_chips = 40,
    l_mult = 4,
    example = {
        { 'S_Q',    true },
        { 'bunc_FLEURON_Q', true },
        { 'C_Q',    true },
        { 'D_8',    true },
        { 'H_8',    true }
    },
    evaluate = function(parts)
        if #parts._3 < 1 or #parts._2 < 2 or not next(parts.bunc_spectrum) then return {} end
        return {SMODS.merge_lists (parts._all_pairs, parts.bunc_spectrum)}
    end
}

SMODS.PokerHand{ -- Spectrum Five (Referenced from SixSuits)
    key = 'Spectrum Five',
    above_hand = 'Flush Five',
    visible = false,
    chips = 180,
    mult = 18,
    l_chips = 55,
    l_mult = 3,
    example = {
        { 'S_7',    true },
        { 'D_7', true },
        { 'bunc_FLEURON_7',    true },
        { 'H_7',    true },
        { 'C_7',    true }
    },
    evaluate = function(parts)
        if not next(parts._5) or not next(parts.bunc_spectrum) then return {} end
        return {SMODS.merge_lists (parts._5, parts.bunc_spectrum)}
    end
}

SMODS.PokerHandPart{ -- Deal base
    key = 'deal',
    func = function(hand)
        if #hand < 5 then
            return {}
        end
        local current_ranks = {}
        local deals = {}

        for _, v in ipairs(SMODS.find_card("j_bunc_registration_plate")) do
            table.insert(deals, v.ability.extra.ranks)
        end

        for i, deal in ipairs(deals) do
            local deal_count = {} -- Counts # of each rank in deal requirement
            local hand_count = {} -- Counts # of each rank in the selected cards

            for _, rank in ipairs(deal) do
                hand_count[rank] = 0
                deal_count[rank] = (deal_count[rank] or 0) + 1
            end

            for j = 1, #hand do
                local match = false -- Every card must match a rank.
                for rank, _ in pairs(deal_count) do
                    if hand[j]:get_id() == rank then
                        match = true
                        hand_count[rank] = hand_count[rank] + 1
                    end
                end
                if not match then
                    return {}
                end
            end

            local equal = true

            for rank, count in pairs(deal_count) do
                if hand_count[rank] < count then -- If deal requires more of a rank than in hand, mark as invalid
                    equal = false
                end
            end

            if equal then
                local self = G.GAME.hands['bunc_Deal']

                self.chips = 0
                self.mult = 0
                self.level = 0

                for k, v in pairs(G.GAME.hands) do
                    if v.visible and v.played > 0 and v ~= self then
                        self.chips = self.chips + v.chips
                        self.mult = self.mult + v.mult
                    end
                end
                return {hand}
            end
        end
        return {}
    end
}

SMODS.PokerHand{ -- Deal
    key = 'Deal',
    above_hand = 'bunc_Spectrum Five',
    visible = false,
    no_collection = true,
    chips = 0,
    mult = 0,
    l_chips = 0,
    l_mult = 0,
    example = {},
    evaluate = function(parts)
        return parts.bunc_deal
    end
}

-- Blinds

SMODS.Atlas({key = 'bunco_blinds', path = 'Blinds/Blinds.png', px = 34, py = 34, frames = 21, atlas_table = 'ANIMATION_ATLAS'})
SMODS.Atlas({key = 'bunco_blinds_finisher', path = 'Blinds/BlindsFinisher.png', px = 34, py = 34, frames = 21, atlas_table = 'ANIMATION_ATLAS'})
BUNCOMOD.funcs.bunc_refresh_boss_blind = function ()
    if G.GAME.blind.boss or not G.blind_select_opts then return end

    local par = G.blind_select_opts.boss.parent
    if 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.blind_select_opts.boss.alignment.offset.y
                },
                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.2
    end
end

SMODS.Blind{ -- The Paling
    key = 'paling',
    boss = {min = 3},

    boss_colour = HEX('45d368'),

    pos = {y = 0},
    atlas = 'bunco_blinds'
}

SMODS.Blind{ -- The Umbrella
    key = 'umbrella',
    boss = {min = 2},

    disable = function(self)
        for i = 1, #G.hand.cards do
            if G.hand.cards[i].facing == 'back' then
                G.hand.cards[i]:flip()
            end
        end
        for k, v in pairs(G.playing_cards) do
            v.ability.wheel_flipped = nil
        end
    end,

    boss_colour = HEX('1e408e'),

    pos = {y = 1},
    atlas = 'bunco_blinds'
}

SMODS.Blind{ -- The Tine
    key = 'tine',
    boss = {min = 2},

    vars = {},
    loc_vars = function(self)
        return {vars = {localize(G.GAME.current_round.most_played_rank, 'ranks')}}
    end,
    collection_loc_vars = function(self)
        return {vars = {localize('bunc_most_played_rank')}}
    end,

    recalc_debuff = function(self, card, from_blind)
        if not G.GAME.blind.disabled and card.area ~= G.jokers and not SMODS.has_no_rank(card) then
            if card.base.value == G.GAME.current_round.most_played_rank then
                card:set_debuff(true)
                return true
            end
            return false
        end
    end,

    boss_colour = HEX('e36cbe'),

    pos = {y = 2},
    atlas = 'bunco_blinds'
}

SMODS.Blind{ -- The Swing
    key = 'swing',
    boss = {min = 3},

    defeat = function(self)
        G.GAME.Swing = false
    end,

    stay_flipped = function(self, area, card)
        if G.GAME.Swing == true then
            return true
        else
            return false
        end
    end,

    disable = function(self)
        for i = 1, #G.hand.cards do
            if G.hand.cards[i].facing == 'back' then
                G.hand.cards[i]:flip()
            end
        end
        for k, v in pairs(G.playing_cards) do
            v.ability.wheel_flipped = nil
        end
    end,

    boss_colour = HEX('17f3d0'),

    pos = {y = 3},
    atlas = 'bunco_blinds'
}

SMODS.Blind{ -- The Miser
    key = 'miser',
    boss = {min = 2},

    defeat = function(self)
        if not G.GAME.blind.disabled then
            G.GAME.Miser = true
        end
    end,

    boss_colour = HEX('991a7f'),

    pos = {y = 4},
    atlas = 'bunco_blinds'
}

SMODS.Blind{ -- The Gate
    key = 'gate',
    boss = {min = 1},

    boss_colour = HEX('c9a27a'),

    pos = {y = 5},
    atlas = 'bunco_blinds'
}

SMODS.Blind{ -- The Flame
    key = 'flame',
    boss = {min = 3},

    recalc_debuff = function(self, card, from_blind)
        if not G.GAME.blind.disabled and card.area ~= G.jokers and card.area ~= G.consumeables then
            if card.config.center.set == "Enhanced" then
                card:set_debuff(true)
                return true
            end
            return false
        end
    end,

    boss_colour = HEX('9b2d49'),

    pos = {y = 6},
    atlas = 'bunco_blinds'
}

SMODS.Blind{ -- The Mask
    key = 'mask',
    boss = {min = 2},

    vars = {},
    loc_vars = function(self)
        G.GAME.current_round.most_played_poker_hand = G.GAME.current_round.most_played_poker_hand or "High Card"
        G.GAME.current_round.least_played_poker_hand = G.GAME.current_round.least_played_poker_hand or "High Card"

        return {vars = {localize(G.GAME.current_round.most_played_poker_hand, 'poker_hands'), localize(G.GAME.current_round.least_played_poker_hand, 'poker_hands')}}
    end,
    collection_loc_vars = function(self)
        return {vars = {localize('ph_most_played'), localize('bunc_least_played_hand')}}
    end,

    modify_hand = function(self, cards, poker_hands, text, mult, hand_chips)
        G.GAME.current_round.most_played_poker_hand = G.GAME.current_round.most_played_poker_hand or "High Card"
        G.GAME.current_round.least_played_poker_hand = G.GAME.current_round.least_played_poker_hand or "High Card"

        if not G.GAME.blind.disabled then
            if G.GAME.last_hand_played == G.GAME.current_round.most_played_poker_hand then
                G.GAME.blind.triggered = true
                return G.GAME.hands[G.GAME.current_round.least_played_poker_hand].s_mult, G.GAME.hands[G.GAME.current_round.least_played_poker_hand].s_chips, true
            end
        end
        return mult, hand_chips, false
    end,

    in_pool = function(self)
        if (G.GAME.round_resets.ante >= self.boss.min) and
            G.GAME.current_round.most_played_poker_hand ~= G.GAME.current_round.most_played_poker_hand 
        then
            return true
        else
            return false
        end
    end,

    boss_colour = HEX('efcca6'),

    pos = {y = 7},
    atlas = 'bunco_blinds'
}

SMODS.Blind{ -- The Bulwark
    key = 'bulwark',
    boss = {min = 2},

    vars = {},
    loc_vars = function(self)
        return {vars = {localize(G.GAME.current_round.most_played_poker_hand, 'poker_hands')}}
    end,
    collection_loc_vars = function(self)
        return {vars = {localize('ph_most_played')}}
    end,

    press_play = function(self)
        if not G.GAME.blind.disabled then
            if G.FUNCS.get_poker_hand_info(G.hand.highlighted) == G.GAME.current_round.most_played_poker_hand then
                local original_limit = G.hand.config.highlighted_limit
                event({ func = function()
                    G.hand.config.highlighted_limit = math.huge
                    if G.hand.cards then
                        for k, v in ipairs(G.hand.cards) do
                            G.hand:add_to_highlighted(v, true)
                            if k <= 3 then
                                play_sound('card1', 1)
                            end
                        end
                        G.hand.config.highlighted_limit = original_limit or 5
                        G.FUNCS.discard_cards_from_highlighted(nil, true)
                        G.GAME.blind:wiggle()
                    end
                return true end })
                G.GAME.blind.triggered = true
                delay(0.7)
            end
        end
    end,

    boss_colour = HEX('672f69'),

    pos = {y = 8},
    atlas = 'bunco_blinds'
}

SMODS.Blind{ -- The Knoll
    key = 'knoll',
    boss = {min = 4},

    stay_flipped = function(self, area, card)
        if not G.GAME.blind.disabled and (area == G.hand) and
        G.GAME.current_round.hands_played == 0 and G.GAME.current_round.discards_used == 0 and #(G.GAME.Knoll or {}) < G.hand.config.card_limit then
            if G.GAME.dollars > to_big(5) then
                G.GAME.Knoll = G.GAME.Knoll or {}
                table.insert(G.GAME.Knoll, card)
                card:set_debuff(true)
            end
        end
    end,
    recalc_debuff = function(self, card, from_blind)
        if not G.GAME.blind.disabled and G.GAME.Knoll then
            for _, debuffed_card in ipairs(G.GAME.Knoll) do
                if debuffed_card == card then
                    return true
                end
            end
            return false
        end
    end,
    defeat = function(self)
        G.GAME.Knoll = nil
    end,

    boss_colour = HEX('6d8f2d'),

    pos = {y = 9},
    atlas = 'bunco_blinds'
}

SMODS.Blind{ -- The Stone
    key = 'stone',
    boss = {min = 4},

    bunc_blind_amount_display = function(self, blind, base_blind_amount, mult)
        return base_blind_amount * (mult + math.floor(to_number(G.GAME.dollars) / 10))
    end,

    set_blind = function(self, reset, silent)
        if not reset then
            G.GAME.blind.original_chips = G.GAME.blind.chips
        end
        if not reset and not G.GAME.blind.disabled and to_big(G.GAME.dollars) >= to_big(10) then
            local final_chips = (G.GAME.blind.chips / G.GAME.blind.mult) * (math.floor(to_number(G.GAME.dollars) / 10) + G.GAME.blind.mult)
            local chip_mod -- iterate over ~120 ticks
            if type(G.GAME.blind.chips) ~= 'table' then
                chip_mod = math.ceil((final_chips - G.GAME.blind.chips) / 120)
            else
                chip_mod = ((final_chips - G.GAME.blind.chips) / 120):ceil()
            end
            local step = 0
            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', 0.8 + (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)
                    G.GAME.blind:wiggle()
                    return true
                end
            end})
        end
    end,

    disable = function()
        G.GAME.blind.chips = G.GAME.blind.original_chips
        G.GAME.blind.chip_text = number_format(G.GAME.blind.chips)
    end,

    boss_colour = HEX('586372'),

    pos = {y = 10},
    atlas = 'bunco_blinds'
}

local bunc_add_tag_ref = add_tag
function add_tag(_tag)
    local ret = bunc_add_tag_ref(_tag)
    if G.GAME.round_resets.blind_choices.Boss == "bl_bunc_sand" then
        G.E_MANAGER:add_event(Event({
        trigger = 'immediate',
        func = function()
            BUNCOMOD.funcs.bunc_refresh_boss_blind()
            return true
        end
        }))
    end
    return ret
end
local bunc_tag_remove_ref = Tag.remove
function Tag:remove()
    local ret = bunc_tag_remove_ref(self)
    if G.GAME.round_resets.blind_choices.Boss == "bl_bunc_sand" then
        BUNCOMOD.funcs.bunc_refresh_boss_blind()
    end
    return ret
end
SMODS.Blind{ -- The Sand
    key = 'sand',
    boss = {min = 4},

    bunc_blind_amount_display = function(self, blind, base_blind_amount, mult)
        return base_blind_amount * (mult + #G.HUD_tags)
    end,

    set_blind = function(self, reset, silent)
        if not reset then
            G.GAME.blind.original_chips = G.GAME.blind.chips
        end
        if not reset and not G.GAME.blind.disabled and #G.HUD_tags ~= 0 then
            local final_chips = (G.GAME.blind.chips / G.GAME.blind.mult) * (#G.HUD_tags + G.GAME.blind.mult)
            local chip_mod -- iterate over ~120 ticks
            if type(G.GAME.blind.chips) ~= 'table' then
                chip_mod = math.ceil((final_chips - G.GAME.blind.chips) / 120)
            else
                chip_mod = ((final_chips - G.GAME.blind.chips) / 120):ceil()
            end
            local step = 0
            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', 0.8 + (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)
                    G.GAME.blind:wiggle()
                    return true
                end
            end})
        end
    end,

    disable = function()
        G.GAME.blind.chips = G.GAME.blind.original_chips
        G.GAME.blind.chip_text = number_format(G.GAME.blind.chips)
    end,

    in_pool = function(self)
        if (G.GAME.round_resets.ante < self.boss.min) or (G.HUD_tags and #G.HUD_tags < 2) then
            return false
        else
            return true
        end
    end,

    boss_colour = HEX('b79131'),

    pos = {y = 11},
    atlas = 'bunco_blinds'
}

SMODS.Blind{ -- The Blade
    key = 'blade',
    boss = {min = 4},

    vars = {},
    loc_vars = function(self)
        local overscore = get_blind_amount(G.GAME.round_resets.ante)*G.P_BLINDS.bl_bunc_blade.mult*G.GAME.starting_params.ante_scaling
        overscore = number_format(overscore * 1.5)
        return {vars = {overscore}}
    end,
    collection_loc_vars = function(self)
        return {vars = {localize('bunc_blade')}}
    end,

    boss_colour = HEX('d92034'),

    pos = {y = 12},
    atlas = 'bunco_blinds'
}

SMODS.Blind{ -- The Claw
    key = 'claw',
    boss = {min = 1},

    boss_colour = HEX('d45741'),

    pos = {y = 13},
    atlas = 'bunco_blinds'
}

SMODS.Blind{ -- The Veil
    key = 'veil',
    boss = {min = 1},

    boss_colour = HEX('ffdf7d'),

    pos = {y = 14},
    atlas = 'bunco_blinds'
}

SMODS.Blind{ -- The Cadaver
    key = 'cadaver',
    boss = {min = 2},

    debuff_hand = function(self, cards, hand, handname, check)
        if not G.GAME.blind.disabled then
            local condition = true
            for i = 1, #cards do
                if cards[i]:is_face() and (cards[i].facing == 'front' or not check) then
                    condition = false
                    break
                end
            end
            return condition
        end
    end,

    in_pool = function(self)
        local face_card = false
        if G.playing_cards then
            for _, card in pairs(G.playing_cards) do
                if card:is_face() then
                    face_card = true
                    break
                end
            end
        end
        return (G.GAME.round_resets.ante >= self.boss.min) and face_card or false
    end,

    boss_colour = HEX('a132d5'),

    pos = {y = 15},
    atlas = 'bunco_blinds'
}

SMODS.Blind{ -- The Wind
    key = 'wind',
    boss = {min = 6},

    drawn_to_hand = function(self)
        if not G.GAME.blind.disabled and G.GAME.current_round.hands_played == 0 and G.GAME.current_round.discards_used == 0 and not G.GAME.bunc_bl_wind_flag then
            G.GAME.blind.ready = true
            if G.jokers and G.jokers.cards[1] then big_juice(G.jokers.cards[1]) end
            G.GAME.blind:wiggle()
            G.GAME.bunc_bl_wind_flag = true
        end
    end,
    defeat = function(self)
        G.GAME.bunc_bl_wind_flag = nil
    end,

    boss_colour = HEX('a6cdef'),

    pos = {y = 16},
    atlas = 'bunco_blinds'
}

SMODS.Blind{ -- The Prince
    key = 'prince',
    boss = {min = 6},

    drawn_to_hand = function(self)
        if not G.GAME.blind.disabled and G.GAME.current_round.hands_played == 0 and G.GAME.current_round.discards_used == 0 then
            G.GAME.blind.ready = true
            if G.jokers and G.jokers.cards then
                for i = 1, #G.jokers.cards do
                    G.GAME.blind:debuff_card(G.jokers.cards[i])
                    big_juice(G.jokers.cards[i])
                end
            end
            G.GAME.blind:wiggle()
        end
        if not G.GAME.blind.disabled and G.GAME.bunc_bl_prince_flag then
            G.GAME.blind:disable()
        end
    end,
    press_play = function(self)
        G.GAME.bunc_bl_prince_flag = true
    end,
    defeat = function(self)
        G.GAME.bunc_bl_prince_flag = nil
    end,

    boss_colour = HEX('f31745'),

    pos = {y = 17},
    atlas = 'bunco_blinds'
}

SMODS.Blind{ -- The Depths
    key = 'depths',
    boss = {min = 4},

    press_play = function(self)
        if not G.GAME.blind.disabled then
            local stickers = {'tag_bunc_eternal', 'tag_bunc_perishable', 'tag_bunc_scattering'}

            add_tag(Tag(stickers[math.random(#stickers)]))

            G.GAME.blind:wiggle()
            G.GAME.blind.triggered = true
            delay(0.7)
        end
    end,

    in_pool = function(self)
        if (G.GAME.round_resets.ante < self.boss.min) or get_deck_win_stake() < 7 then
            return false
        else
            return true
        end
    end,

    boss_colour = HEX('3f3f3f'),

    pos = {y = 18},
    atlas = 'bunco_blinds'
}

SMODS.Blind{ -- The Chasm
    key = 'chasm',
    boss = {min = 4},

    press_play = function(self)
        if not G.GAME.blind.disabled then
            local stickers = {'tag_bunc_hindered', 'tag_bunc_reactive', 'tag_bunc_rental'}

            add_tag(Tag(stickers[math.random(#stickers)]))

            G.GAME.blind:wiggle()
            G.GAME.blind.triggered = true
            delay(0.7)
        end
    end,

    in_pool = function(self)
        if (G.GAME.round_resets.ante < self.boss.min) or get_deck_win_stake() < 10 then
            return false
        else
            return true
        end
    end,

    boss_colour = HEX('553529'),

    pos = {y = 19},
    atlas = 'bunco_blinds'
}

-- Finishers

SMODS.Blind{ -- Chartreuse Crown
    key = 'final_crown',
    boss = {showdown = true, min = 10, max = 10},

    dollars = 8,

    recalc_debuff = function(self, card, from_blind)
        if not G.GAME.blind.disabled and card.area ~= G.jokers then
            if card.base.suit == ('Spades') or
            card.base.suit == ('Hearts') or
            card.base.suit == ('Clubs') or
            card.base.suit == ('Diamonds') then
                if not SMODS.has_no_suit(card) then
                    card:set_debuff(true)
                    return true
                end
            end
            return false
        end
    end,

    in_pool = function()
        local exotic_amount = 0

        if G.playing_cards then
            for k, v in pairs(G.playing_cards) do
                if (v.base.suit == ('bunc_Fleurons') or
                v.base.suit == ('bunc_Halberds')) and
                not SMODS.has_no_suit(v) then
                    exotic_amount = exotic_amount + 1
                end
            end
        end

        if exotic_amount >= 10 then
            return true
        else
            return false
        end
    end,

    boss_colour = HEX('96a756'),

    pos = {y = 0},
    atlas = 'bunco_blinds_finisher'
}

SMODS.Blind{ -- Vermilion Trident
    key = 'final_trident',
    boss = {showdown = true, min = 10, max = 10},

    dollars = 8,

    bunc_blind_amount_display = function(self, blind, base_blind_amount, mult)
        return base_blind_amount * (mult + G.GAME.ante_purchases)
    end,

    calculate = function(self, blind, context)
    end,

    set_blind = function(self, reset, silent)
        if not reset then
            G.GAME.blind.original_chips = G.GAME.blind.chips
        end
        if not reset and not G.GAME.blind.disabled and G.GAME.ante_purchases then
            local final_chips = (G.GAME.blind.chips / G.GAME.blind.mult) * (G.GAME.ante_purchases + G.GAME.blind.mult)
            local chip_mod -- iterate over ~120 ticks
            if type(G.GAME.blind.chips) ~= 'table' then
                chip_mod = math.ceil((final_chips - G.GAME.blind.chips) / 120)
            else
                chip_mod = ((final_chips - G.GAME.blind.chips) / 120):ceil()
            end
            local step = 0
            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', 0.8 + (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)
                    G.GAME.blind:wiggle()
                    return true
                end
            end})
        end
    end,

    disable = function()
        G.GAME.blind.chips = G.GAME.blind.original_chips
        G.GAME.blind.chip_text = number_format(G.GAME.blind.chips)
    end,

    boss_colour = HEX('db481e'),

    pos = {y = 1},
    atlas = 'bunco_blinds_finisher'
}

SMODS.Blind{ -- Indigo Tower
    key = 'final_tower',
    boss = {showdown = true, min = 10, max = 10},

    dollars = 8,

    recalc_debuff = function(self, card, from_blind)
        if not G.GAME.blind.disabled and card.area ~= G.jokers and card.area ~= G.consumeables then
            if not card.ability.played_this_ante then
                card:set_debuff(true)
                return true
            end
            return false
        end
    end,

    boss_colour = HEX('4f4caa'),

    pos = {y = 2},
    atlas = 'bunco_blinds_finisher'
}

SMODS.Blind{ -- Magenta Dagger
    key = 'final_dagger',
    boss = {showdown = true, min = 10, max = 10},

    dollars = 8,

    boss_colour = HEX('cb589f'),

    pos = {y = 3},
    atlas = 'bunco_blinds_finisher'
}

SMODS.Blind{ -- Turquoise Shield
    key = 'final_shield',
    boss = {showdown = true, min = 10, max = 10},

    bunc_blind_amount_display = function(self, blind, base_blind_amount, mult)
        return base_blind_amount * mult + (G.GAME.overscore or 0)
    end,

    dollars = 8,

    set_blind = function(self, reset, silent)
        if not reset then
            G.GAME.blind.original_chips = G.GAME.blind.chips
        end
        if not reset and not G.GAME.blind.disabled and G.GAME.overscore and G.GAME.overscore ~= 0 then
            local final_chips = (G.GAME.blind.chips) + (G.GAME.overscore or 0)
            local chip_mod -- iterate over ~120 ticks
            if type(G.GAME.blind.chips) ~= 'table' then
                chip_mod = math.ceil((final_chips - G.GAME.blind.chips) / 120)
            else
                chip_mod = ((final_chips - G.GAME.blind.chips) / 120):ceil()
            end
            local step = 0
            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', 0.8 + (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)
                    G.GAME.blind:wiggle()
                    return true
                end
            end})
        end
    end,

    disable = function()
        G.GAME.blind.chips = G.GAME.blind.original_chips
        G.GAME.blind.chip_text = number_format(G.GAME.blind.chips)
    end,

    defeat = function(self)
        G.GAME.Shield = false
    end,

    boss_colour = HEX('12e2bf'),

    pos = {y = 4},
    atlas = 'bunco_blinds_finisher'
}

-- Decks

SMODS.Atlas({key = 'bunco_decks', path = 'Decks/Decks.png', px = 71, py = 95})

SMODS.Back{ -- Fairy
	key = 'fairy',

    config = {amount = 4},
    loc_vars = function(self)
        return {vars = {self.config.amount, localize{type = 'name_text', set = 'Other', key = 'bunc_exotic_cards'}}}
    end,

    unlocked = false,

    apply = function()
        enable_exotics()
    end,
    calculate = function(self, back, context)
        if context.round_eval and G.GAME.last_blind and G.GAME.last_blind.boss then
            event({
                func = (function()
                    local numbers = {}
                    for _, v in ipairs(SMODS.Rank.obj_buffer) do
                        local r = SMODS.Ranks[v]
                        table.insert(numbers, r.card_key)
                    end

                    local suits = {'bunc_FLEURON', 'bunc_HALBERD'}
                    local cards = {}

                    for i = 1, self.config.amount do
                        local rank = pseudorandom_element(numbers, pseudoseed('fairy'..G.SEED))
                        local suit = pseudorandom_element(suits, pseudoseed('fairy'..G.SEED))
                        table.insert(cards, create_playing_card({front = G.P_CARDS[suit .. '_' .. rank]}, G.deck, false, false, {G.C.BUNCO_EXOTIC}))
                    end

                    playing_card_joker_effects(cards)

                    return true
                end)
            })
        end
    end,

    pos = coordinate_from_atlas_index(1),
    atlas = 'bunco_decks'
}

SMODS.Back{ -- Digital
	key = 'digital',

    config = {polymino_rate = 2, consumables = {'c_bunc_the_i'}},
    loc_vars = function(self)
        return {}
    end,

    unlocked = false,
    unlock_condition = {type = 'win_stake', stake = 8},

    apply = function(self)
        G.GAME.polymino_rate = self.config.polymino_rate
    end,

    pos = coordinate_from_atlas_index(2),
    atlas = 'bunco_decks'
}

-- Tags

SMODS.Atlas({key = 'bunco_tags', path = 'Tags/Tags.png', px = 34, py = 34})
SMODS.Atlas({key = 'bunco_tags_edition', path = 'Tags/TagsEdition.png', px = 34, py = 34})
SMODS.Atlas({key = 'bunco_tags_hand', path = 'Tags/TagsHand.png', px = 34, py = 34})
SMODS.Atlas({key = 'bunco_tags_exotic', path = 'Tags/TagsExotic.png', px = 34, py = 34})
SMODS.Atlas({key = 'bunco_tags_sticker', path = 'Tags/TagsSticker.png', px = 34, py = 34})

SMODS.Tag{ -- Breaking
    key = 'breaking',

    config = {type = 'round_start_bonus'},

    apply = function(self, tag, context)
        if context.type == self.config.type or context.type == "immediate" then
            if G.GAME.blind and G.GAME.blind.boss and not G.GAME.blind.disabled then
                tag:yep('+', G.C.BLUE, function()
                    return true
                end)

                event({ func = function()
                    G.GAME.blind:disable()
                    return true 
                end })

                tag.triggered = true
                return true
            end
        end
    end,

    pos = coordinate_from_atlas_index(1),
    atlas = 'bunco_tags',

    in_pool = function()
        if pseudorandom('breaking'..G.SEED) < 0.07 then
            return true
        else
            return false
        end
    end
}

SMODS.Tag{ -- Arcade
    key = 'arcade',
    loc_vars = function(self, info_queue)
        info_queue[#info_queue + 1] = {key = 'p_bunc_virtual_mega', set = 'Other', vars = {G.P_CENTERS.p_bunc_virtual_mega.config.choose, G.P_CENTERS.p_bunc_virtual_mega.config.extra}}
        return {}
    end,

    config = {type = 'new_blind_choice'},

    apply = function(self, tag, context)
        if context.type == self.config.type then
            G.CONTROLLER.locks[tag.ID] = true
            tag:yep('+', G.C.BUNCO_VIRTUAL, function()
                local key = 'p_bunc_virtual_mega'
                local card = Card(G.play.T.x + G.play.T.w/2 - G.CARD_W*1.27/2,
                G.play.T.y + G.play.T.h/2-G.CARD_H*1.27/2, G.CARD_W*1.27, G.CARD_H*1.27, G.P_CARDS.empty, G.P_CENTERS[key], {bypass_discovery_center = true, bypass_discovery_ui = true})
                card.cost = 0
                card.from_tag = true
                G.FUNCS.use_card({config = {ref_table = card}})
                card:start_materialize()
                G.CONTROLLER.locks[tag.ID] = nil
                return true
            end)
            tag.triggered = true
            return true
        end
    end,

    pos = coordinate_from_atlas_index(2),
    atlas = 'bunco_tags',

    in_pool = function()
        if pseudorandom('arcade'..G.SEED) < 0.1 then
            return true
        else
            return false
        end
    end
}

SMODS.Tag{ -- Triple
    key = 'triple',

    config = {type = 'tag_add'},

    apply = function(self, tag, context)
        if context.type == self.config.type and context.tag.key ~= 'tag_double' and context.tag.key ~= 'tag_bunc_triple' then
            G.CONTROLLER.locks[tag.ID] = true
            tag:yep('+', G.C.BUNCO_VIRTUAL, function()
                if context.tag.ability and context.tag.ability.orbital_hand then
                    G.orbital_hand = context.tag.ability.orbital_hand
                end
                add_tag(Tag(context.tag.key))
                add_tag(Tag(context.tag.key))
                G.orbital_hand = nil
                G.CONTROLLER.locks[tag.ID] = nil
                return true
            end)
            tag.triggered = true
            return true
        end
    end,

    pos = coordinate_from_atlas_index(3),
    atlas = 'bunco_tags',

    in_pool = function() return G.GAME.used_vouchers['v_bunc_pin_collector'] end
}

SMODS.Tag{ -- Glitter
    key = 'glitter',

    config = {type = 'store_joker_modify', edition = 'bunc_glitter', odds = 4},
    loc_vars = function(self, info_queue)
        info_queue[#info_queue+1] = G.P_CENTERS.e_bunc_glitter
        return {}
    end,

    apply = function(self, tag, context)
        if context.type == self.config.type then
            local applied = nil
            if context.card and not context.card.edition and not context.card.temp_edition and context.card.ability.set == 'Joker' then
                local lock = tag.ID
                G.CONTROLLER.locks[lock] = true

                context.card.temp_edition = true
                tag:yep('+', G.C.DARK_EDITION, function()
                    context.card:set_edition({bunc_glitter = true}, true)
                    context.card.ability.couponed = true
                    context.card:set_cost()
                    context.card.temp_edition = nil
                    G.CONTROLLER.locks[lock] = nil
                    return true
                end)
                applied = true

                tag.triggered = true
            end
            return applied
        end
    end,

    pos = coordinate_from_atlas_index(1),
    atlas = 'bunco_tags_edition',
}

SMODS.Tag{ -- Fluorescent
    key = 'fluorescent',

    config = {type = 'store_joker_modify', edition = 'bunc_fluorescent', odds = 4},
    loc_vars = function(self, info_queue)
        info_queue[#info_queue+1] = G.P_CENTERS.e_bunc_fluorescent
        return {}
    end,

    apply = function(self, tag, context)
        if context.type == self.config.type then
            local applied = nil
            if context.card and not context.card.edition and not context.card.temp_edition and context.card.ability.set == 'Joker' then
                local lock = tag.ID
                G.CONTROLLER.locks[lock] = true

                context.card.temp_edition = true
                tag:yep('+', G.C.DARK_EDITION, function()
                    context.card:set_edition({bunc_fluorescent = true}, true)
                    context.card.ability.couponed = true
                    context.card:set_cost()
                    context.card.temp_edition = nil
                    G.CONTROLLER.locks[lock] = nil
                    return true
                end)
                applied = true

                tag.triggered = true
            end
            return applied
        end
    end,

    pos = coordinate_from_atlas_index(2),
    atlas = 'bunco_tags_edition',

    in_pool = function()
        if pseudorandom('fluorescent'..G.SEED) < 0.5 then
            return true
        else
            return false
        end
    end
}

SMODS.Tag{ -- Filigree
    key = 'filigree',

    config = {type = 'standard_pack_opened'},
    loc_vars = function(self, info_queue)
        info_queue[#info_queue+1] = {set = 'Other', key = 'bunc_exotic_cards'}
        return {}
    end,
    apply = function(self, tag, context)
        if context.type == self.config.type then
            tag:instayep('+', G.C.BUNCO_EXOTIC, function()
                return true
            end)
            event({
                trigger = 'after',
                delay = 0,
                blockable = false,
                blocking = false,
                func = function()
                    if G.pack_cards and G.pack_cards.cards ~= nil and G.pack_cards.cards[1] and G.pack_cards.VT.y < G.ROOM.T.h then

                        enable_exotics()

                        for _, v in ipairs(G.pack_cards.cards) do
                            if (not v:is_suit('bunc_Fleurons') and not v:is_suit('bunc_Halberds')) or SMODS.has_any_suit(v) then
                                local suits = {'bunc_Fleurons', 'bunc_Halberds'}
                                local suit = pseudorandom_element(suits, pseudoseed('filigree'..G.SEED))
                                v:change_suit(suit)
                            end
                        end

                        return true
                    end
                end
            })
            tag.triggered = true
            return true
        end
    end,

    pos = coordinate_from_atlas_index(1),
    atlas = 'bunco_tags_exotic',

    in_pool = BUNCOMOD.funcs.exotic_in_pool
}

SMODS.Tag{ -- Chips
    key = 'chips',

    config = {type = 'hand_played'},
    loc_vars = function(self, info_queue)
        return {vars = {G.P_CENTERS.e_foil.config.extra}}
    end,
    apply = function(self, tag, context)
        if context.type == self.config.type then
            if context.before then

                hand_chips = mod_chips(hand_chips + G.P_CENTERS.e_foil.config.extra)
                update_hand_text({delay = 0}, {chips = hand_chips})

                tag:instayep('+', G.C.CHIPS, function()
                    return true
                end, 0)
                tag.triggered = true
                return true
            end
        end
    end,

    pos = coordinate_from_atlas_index(1),
    atlas = 'bunco_tags_hand',

    in_pool = function() return false end
}

SMODS.Tag{ -- Mult
    key = 'mult',

    config = {type = 'hand_played'},
    loc_vars = function(self, info_queue)
        return {vars = {G.P_CENTERS.e_holo.config.extra}}
    end,
    apply = function(self, tag, context)
        if context.type == self.config.type then
            if context.before then

                mult = mod_mult(mult + G.P_CENTERS.e_holo.config.extra)
                update_hand_text({delay = 0}, {mult = mult})

                tag:instayep('+', G.C.MULT, function()
                    return true
                end, 0)
                tag.triggered = true
                return true
            end
        end
    end,

    pos = coordinate_from_atlas_index(2),
    atlas = 'bunco_tags_hand',

    in_pool = function() return false end
}

SMODS.Tag{ -- Xmult
    key = 'xmult',

    config = {type = 'hand_played'},
    loc_vars = function(self, info_queue)
        return {vars = {G.P_CENTERS.e_polychrome.config.extra}}
    end,
    apply = function(self, tag, context)
        if context.type == self.config.type then
            if context.after then

                mult = mod_mult(mult * G.P_CENTERS.e_polychrome.config.extra)
                update_hand_text({delay = 0}, {mult = mult})

                tag:instayep('+', G.C.MULT, function()
                    return true
                end, 0)
                tag.triggered = true
                return true
            end
        end
    end,

    pos = coordinate_from_atlas_index(3),
    atlas = 'bunco_tags_hand',

    in_pool = function() return false end
}

SMODS.Tag{ -- Xchip
    key = 'xchips',

    config = {type = 'hand_played', odds = -1},
    loc_vars = function(self, info_queue)
        return {vars = {G.P_CENTERS.e_bunc_glitter.config.Xchips}}
    end,
    apply = function(self, tag, context)
        if context.type == self.config.type then
            if context.after then

                hand_chips = mod_chips(hand_chips * G.P_CENTERS.e_bunc_glitter.config.Xchips)
                update_hand_text({delay = 0}, {chips = hand_chips})

                tag:instayep('+', G.C.CHIPS, function()
                    return true
                end, 0)
                tag.triggered = true
                return true
            end
        end
    end,

    pos = coordinate_from_atlas_index(4),
    atlas = 'bunco_tags_hand',

    in_pool = function() return false end
}

SMODS.Tag{ -- Eternal
    key = 'eternal',

    config = {type = 'store_joker_modify'},
    loc_vars = function(self, info_queue)
        info_queue[#info_queue + 1] = {key = 'eternal', set = 'Other'}
        return {}
    end,

    apply = function(self, tag, context)
        if context.type == self.config.type then
            if context.card and 
                not context.card.ability.eternal and 
                not context.card.ability.perishable and 
                not context.card.ability.bunc_scattering and
                not context.card.ability.bunc_hindered and
                context.card.ability.set == 'Joker' and
                context.card.config.center.eternal_compat
            then
                local lock = tag.ID
                G.CONTROLLER.locks[lock] = true
                tag:yep('+', G.C.RED, function()
                    context.card:set_eternal(true)
                    big_juice(context.card)
                    context.card:set_cost()
                    G.CONTROLLER.locks[lock] = nil
                    return true
                end)

                tag.triggered = true
            end
            return true
        end
    end,

    pos = coordinate_from_atlas_index(1),
    atlas = 'bunco_tags_sticker',

    in_pool = function() return false end
}

SMODS.Tag{ -- Perishable
    key = 'perishable',

    config = {type = 'store_joker_modify'},
    loc_vars = function(self, info_queue)
        info_queue[#info_queue + 1] = {key = 'perishable', set = 'Other', vars = {G.GAME.perishable_rounds or 1, G.GAME.perishable_rounds or G.GAME.perishable_rounds}}
        return {}
    end,

    apply = function(self, tag, context)
        if context.type == self.config.type then
            if context.card and 
                not context.card.ability.perishable and 
                not context.card.ability.eternal and 
                context.card.ability.set == 'Joker' and
                context.card.config.center.perishable_compat
            then
                local lock = tag.ID
                G.CONTROLLER.locks[lock] = true
                tag:yep('+', G.C.RED, function()
                    context.card:set_perishable(true)
                    big_juice(context.card)
                    context.card:set_cost()
                    G.CONTROLLER.locks[lock] = nil
                    return true
                end)

                tag.triggered = true
            end
            return true
        end
    end,

    pos = coordinate_from_atlas_index(2),
    atlas = 'bunco_tags_sticker',

    in_pool = function() return false end
}

SMODS.Tag{ -- Scattering
    key = 'scattering',

    config = {type = 'store_joker_modify'},
    loc_vars = function(self, info_queue)
        info_queue[#info_queue + 1] = {key = 'bunc_scattering', set = 'Other'}
        return {}
    end,

    apply = function(self, tag, context)
        if context.type == self.config.type then
            if context.card
            and not context.card.ability.bunc_scattering
            and not context.card.ability.bunc_hindered
            and not context.card.ability.bunc_reactive
            and not context.card.ability.eternal
            and context.card.ability.set == 'Joker' then
                local lock = tag.ID
                G.CONTROLLER.locks[lock] = true
                tag:yep('+', G.C.RED, function()
                    SMODS.Stickers['bunc_scattering']:apply(context.card, true)
                    big_juice(context.card)
                    context.card:set_cost()
                    G.CONTROLLER.locks[lock] = nil
                    return true
                end)

                tag.triggered = true
            end
            return true
        end
    end,

    pos = coordinate_from_atlas_index(3),
    atlas = 'bunco_tags_sticker',

    in_pool = function() return false end
}

SMODS.Tag{ -- Hindered
    key = 'hindered',

    config = {type = 'store_joker_modify'},
    loc_vars = function(self, info_queue)
        info_queue[#info_queue + 1] = {key = 'bunc_hindered', set = 'Other'}
        return {}
    end,

    apply = function(self, tag, context)
        if context.type == self.config.type then
            if context.card
            and not context.card.ability.bunc_scattering
            and not context.card.ability.bunc_hindered
            and not context.card.ability.bunc_reactive
            and not context.card.ability.eternal
            and context.card.ability.set == 'Joker' then
                local lock = tag.ID
                G.CONTROLLER.locks[lock] = true
                tag:yep('+', G.C.RED, function()
                    SMODS.Stickers['bunc_hindered']:apply(context.card, true)
                    big_juice(context.card)
                    context.card:set_cost()
                    G.CONTROLLER.locks[lock] = nil
                    return true
                end)

                tag.triggered = true
            end
            return true
        end
    end,

    pos = coordinate_from_atlas_index(4),
    atlas = 'bunco_tags_sticker',

    in_pool = function() return false end
}

SMODS.Tag{ -- Reactive
    key = 'reactive',

    config = {type = 'store_joker_modify'},
    loc_vars = function(self, info_queue)
        info_queue[#info_queue + 1] = {key = 'bunc_reactive', set = 'Other'}
        return {}
    end,

    apply = function(self, tag, context)
        if context.type == self.config.type then
            if context.card
            and not context.card.ability.bunc_scattering
            and not context.card.ability.bunc_hindered
            and not context.card.ability.bunc_reactive
            and context.card.ability.set == 'Joker' then
                local lock = tag.ID
                G.CONTROLLER.locks[lock] = true
                tag:yep('+', G.C.RED, function()
                    SMODS.Stickers['bunc_reactive']:apply(context.card, true)
                    big_juice(context.card)
                    context.card:set_cost()
                    G.CONTROLLER.locks[lock] = nil
                    return true
                end)

                tag.triggered = true
            end
            return true
        end
    end,

    pos = coordinate_from_atlas_index(5),
    atlas = 'bunco_tags_sticker',

    in_pool = function() return false end
}

SMODS.Tag{ -- Rental
    key = 'rental',

    config = {type = 'store_joker_modify'},
    loc_vars = function(self, info_queue)
        info_queue[#info_queue+1] = {key = 'rental', set = 'Other', vars = {G.GAME.rental_rate or 1}}
        return {}
    end,

    apply = function(self, tag, context)
        if context.type == self.config.type then
            if context.card and not context.card.ability.rental and context.card.ability.set == 'Joker' then
                local lock = tag.ID
                G.CONTROLLER.locks[lock] = true
                tag:yep('+', G.C.RED, function()
                    context.card:set_rental(true)
                    big_juice(context.card)
                    context.card:set_cost()
                    G.CONTROLLER.locks[lock] = nil
                    return true
                end)

                tag.triggered = true
            end
            return true
        end
    end,

    pos = coordinate_from_atlas_index(6),
    atlas = 'bunco_tags_sticker',

    in_pool = function() return false end
}

-- Editions

SMODS.Shader({key = 'glitter', path = 'glitter.fs'})
SMODS.Sound({key = 'glitter', path = 'glitter.ogg'})

SMODS.Edition{
    key = 'glitter',

    config = {Xchips = 1.3},
    loc_vars = function(self, info_queue)
        return {vars = {self.config.Xchips}}
    end,

    calculate = function(self, card, context)
        if context.post_joker or (context.main_scoring and context.cardarea == G.play) then
            return {func = function()
                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(card, 'extra', nil, percent, nil,
                {message = 'X'..xchips..' '..G.localization.misc.dictionary.bunc_chips,
                edition = true,
                x_chips = true})
            end}
        end
    end,

    sound = {sound = 'bunc_glitter', per = 1.2, vol = 0.4},
    in_shop = true,
    weight = 9,
    extra_cost = 3,
    get_weight = function(self)
        return G.GAME.edition_rate * self.weight
    end,

    shader = 'glitter'
}

SMODS.Shader({key = 'fluorescent', path = 'fluorescent.fs'})
SMODS.Sound({key = 'fluorescent', path = 'fluorescent.ogg'})

SMODS.Edition{
    key = 'fluorescent',

    sound = {sound = 'bunc_fluorescent', per = 1.2, vol = 0.4},
    in_shop = true,
    weight = 18,
    extra_cost = 1,
    get_weight = function(self)
        return G.GAME.edition_rate * self.weight
    end,

    shader = 'fluorescent'
}

-- Vouchers

SMODS.Atlas({key = 'bunco_vouchers', path = 'Vouchers/Vouchers.png', px = 71, py = 95})

SMODS.Voucher{ -- Lamination
    key = 'lamination',

    unlocked = true,

    pos = coordinate_from_atlas_index(1),
    atlas = 'bunco_vouchers'
}

SMODS.Voucher{ -- Supercoating
    key = 'supercoating',

    config = {unlock = 5},
    locked_loc_vars = function(self, info_queue, card)
        return {vars = {self.config.unlock, G.PROFILES[G.SETTINGS.profile].consumables_with_edition_used or 0}}
    end,

    requires = {'v_bunc_lamination'},

    unlocked = false,

    check_for_unlock = function(self, args)
        if args.type == 'use_consumable_with_edition' and args.used_total >= self.config.unlock then
            unlock_card(self)
        end
    end,

    pos = coordinate_from_atlas_index(2),
    atlas = 'bunco_vouchers'
}

SMODS.Voucher{ -- Hedge Trimmer
    key = 'hedge_trimmer',

    config = {percent = 5},
    loc_vars = function(self, info_queue)
        return {vars = {self.config.percent}}
    end,

    unlocked = true,

    pos = coordinate_from_atlas_index(3),
    atlas = 'bunco_vouchers'
}

SMODS.Voucher{ -- Chainsaw
    key = 'chainsaw',

    config = {percent = 20, unlock = 20},
    loc_vars = function(self, info_queue)
        return {vars = {self.config.percent}}
    end,
    locked_loc_vars = function(self, info_queue, card)
        return {vars = {self.config.unlock, G.PROFILES[G.SETTINGS.profile].hedge_trimmer_usage or 0}}
    end,

    requires = {'v_bunc_hedge_trimmer'},

    redeem = function(self)
        G.GAME.starting_params.ante_scaling = (G.GAME.starting_params.ante_scaling / 100) * (100 - self.config.percent)
    end,

    unlocked = false,

    check_for_unlock = function(self, args)
        if args.type == 'hedge_trimmer_used' and args.used_total >= self.config.unlock then
            unlock_card(self)
        end
    end,

    pos = coordinate_from_atlas_index(4),
    atlas = 'bunco_vouchers'
}

SMODS.Voucher{ -- Cups 'n' Balls
    key = 'cups_n_balls',

    redeem = function(self)
        G.GAME.modifiers.extra_boosters = (G.GAME.modifiers.extra_boosters or 0) + 1
        SMODS.add_booster_to_shop()
    end,

    unlocked = true,

    pos = coordinate_from_atlas_index(5),
    atlas = 'bunco_vouchers'
}

SMODS.Voucher{ -- Shell Game
    key = 'shell_game',

    config = {unlock = 25},
    locked_loc_vars = function(self, info_queue, card)
        return {vars = {self.config.unlock, G.PROFILES[G.SETTINGS.profile].booster_packs_opened or 0}}
    end,

    requires = {'v_bunc_cups_n_balls'},

    unlocked = false,

    check_for_unlock = function(self, args)
        if args.type == 'open_pack' and args.packs_total >= self.config.unlock then
            unlock_card(self)
        end
    end,

    pos = coordinate_from_atlas_index(6),
    atlas = 'bunco_vouchers'
}

SMODS.Voucher{ -- Disguise
    key = 'disguise',

    unlocked = true,

    pos = coordinate_from_atlas_index(7),
    atlas = 'bunco_vouchers'
}

SMODS.Voucher{ -- Masquerade
    key = 'masquerade',

    config = {unlock = 5},
    locked_loc_vars = function(self, info_queue, card)
        return {vars = {self.config.unlock, G.PROFILES[G.SETTINGS.profile].blind_cards_used or 0}}
    end,

    requires = {'v_bunc_disguise'},

    redeem = function(self)
        if G.shop_booster and G.shop_booster.cards then
            for _, booster in ipairs(G.shop_booster.cards) do
                if booster.config.center.type == 'bunc_blind' then
                    booster.cost = 0
                end
            end
        end
    end,

    unlocked = false,

    check_for_unlock = function(self, args)
        if args.type == 'use_blind_card' and args.blinds_total >= self.config.unlock then
            unlock_card(self)
        end
    end,

    pos = coordinate_from_atlas_index(8),
    atlas = 'bunco_vouchers'
}

SMODS.Voucher{ -- Fanny Pack
    key = 'fanny_pack',

    config = {extra = {odds = 4}},
    loc_vars = function(self, info_queue, card)

        info_queue[#info_queue+1] = {set = 'Tag', key = 'tag_double'}

        local vars = {SMODS.get_probability_vars(card, 1, card.ability.extra.odds)}
        return {vars = vars}
    end,

    unlocked = true,

    pos = coordinate_from_atlas_index(9),
    atlas = 'bunco_vouchers'
}

SMODS.Voucher{ -- Pin Collector
    key = 'pin_collector',

    config = {unlock = 30},
    loc_vars = function(self, info_queue, card)
        info_queue[#info_queue+1] = {set = 'Tag', key = 'tag_bunc_triple'}
        return {}
    end,
    locked_loc_vars = function(self, info_queue, card)
        return {vars = {self.config.unlock, G.PROFILES[G.SETTINGS.profile].skips_total or 0}}
    end,

    requires = {'v_bunc_fanny_pack'},

    unlocked = false,

    check_for_unlock = function(self, args)
        if args.type == 'blind_skipped' and args.skips_total >= self.config.unlock then
            unlock_card(self)
        end
    end,

    pos = coordinate_from_atlas_index(10),
    atlas = 'bunco_vouchers'
}

SMODS.Voucher{ -- Arcade Machine
    key = 'arcade_machine',

    unlocked = true,

    pos = coordinate_from_atlas_index(11),
    atlas = 'bunco_vouchers'
}

SMODS.Voucher{ -- Polybius
    key = 'polybius',

    config = {unlock = 10},
    locked_loc_vars = function(self, info_queue, card)
        return {vars = {self.config.unlock, G.PROFILES[G.SETTINGS.profile].cards_linked or 0}}
    end,

    requires = {'v_bunc_arcade_machine'},

    unlocked = false,

    check_for_unlock = function(self, args)
        if args.type == 'link_cards' and args.links_total >= self.config.unlock then
            unlock_card(self)
        end
    end,

    pos = coordinate_from_atlas_index(12),
    atlas = 'bunco_vouchers'
}

-- Blind Cards

function Card:create_blind_card()

    if pseudorandom('the_joker'..G.SEED) < 0.04 and G.P_CENTERS['j_bunc_the_joker'].unlocked and not (G.GAME.used_jokers['j_bunc_the_joker'] and not next(find_joker('Showman'))) then
        return create_card('Joker', G.pack_cards, nil, nil, true, true, 'j_bunc_the_joker', 'buf')
    end

    self = Card(self.T.x, self.T.y, 0.8*G.CARD_W, 0.8*G.CARD_W, nil, G.P_CENTERS.c_base)

    -- Blind acquiring like in the base game

    local boss

    if not TW_BL then -- TW_BL is for Twich Blinds mod
        boss = get_new_boss()
    else
        boss = TW_BL.UTILITIES.get_new_bosses(0, 1)[1]
    end

    local blind = G.P_BLINDS[boss]

    -- Blind appearance

    self.children.center = Sprite(self.T.x, self.T.y, self.T.w, self.T.w, G.ANIMATION_ATLAS[blind.atlas] or G.ANIMATION_ATLAS['blind_chips'], {x = blind.pos.x or 0, y = blind.pos.y or 0})
    self.children.center.states.hover = self.states.hover
    self.children.center.states.click = self.states.click
    self.children.center.states.drag = self.states.drag
    self.children.center.states.collide.can = false
    self.children.center:set_role({role_type = 'Glued', major = self, draw_major = self,
    xy_bond = 'Strong',
    wh_bond = 'Strong',
    r_bond = 'Strong',
    scale_bond = 'Strong'})

    self.children.back = self.children.center

    self.ability.blind_card = {blind = blind}

    self.hover = function()
        if not G.CONTROLLER.dragging.target or G.CONTROLLER.using_touch then 
            if not self.hovering and self.states.visible then
                    self.hovering = true
                    self.hover_tilt = 3
                    self:juice_up(0.05, 0.02)
                play_sound('chips1', math.random() * 0.1 + 0.55, 0.12)
                self.config.h_popup = create_UIBox_blind_popup(self.ability.blind_card.blind, true)
                self.config.h_popup_config = {align = 'tm', offset = {x = 0, y = -0.13}, parent = self}
                Node.hover(self)
                if self.children.alert then 
                    self.children.alert:remove()
                    self.children.alert = nil
                    self.config.blind.alerted = true
                    G:save_progress()
                end
            end
        end
        self.stop_hover = function() self.hovering = false; Node.stop_hover(self); self.hover_tilt = 0 end
    end

    return self
end

-- Booster Packs

SMODS.Atlas({key = 'bunco_booster_packs_blind', path = 'Boosters/BoostersBlind.png', px = 71, py = 95})
SMODS.Atlas({key = 'bunco_booster_packs_virtual', path = 'Boosters/BoostersVirtual.png', px = 71, py = 95})

-- Blind pack functionality

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
    G.GAME.round_resets.blind_choices.Boss = boss

    play_sound('other1')

    e.config.button = nil

    if G.blind_select_opts.boss then
        BUNCOMOD.funcs.bunc_refresh_boss_blind()
    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
        check_for_unlock({type = 'use_blind_card', blinds_total = G.PROFILES[G.SETTINGS.profile].blind_cards_used})
    end

    G.FUNCS.end_consumeable(nil, 0.2)
end

for i = 1, 4 do -- Blind
    SMODS.Booster{
        type = 'bunc_blind',

        key = 'blind_'..i,

        loc_vars = function(self, info_queue, card)
            return {key = 'p_bunc_blind', vars = {self.config.extra}}
        end,
        config = {extra = 3, choose = 1},

        cost = 8,
        weight = 1,

        create_card = function(self, card)
            return card:create_blind_card()
        end,
        update_pack = function(self, dt)
            SMODS.Booster.update_pack(self, dt)
            G.GAME.pack_choices = 1
        end,

        sparkles = {colours = {HEX('19ee94'), HEX('ecbe69'), HEX('ee80cd'), HEX('9894e2')}},
        ease_background_colour = function(self)
            ease_colour(G.C.DYN_UI.MAIN, HEX('4d7796'))
            ease_background_colour{new_colour = HEX('4d7796'), special_colour = HEX('c7d775'), contrast = 2}
        end,

        create_UIBox = function(self) -- I don't know if I should do it like that, but since I can't inject into steamodded's files directly I do this
                                    -- However I could mess with the node structure instead of repeating the whole thing. Do you want me to suffer?
                                    -- Look at this mess. Terrible
            local _size = SMODS.OPENED_BOOSTER.ability.extra
            G.pack_cards = CardArea(
                G.ROOM.T.x + 9 + G.hand.T.x, G.hand.T.y,
                math.max(1,math.min(_size,5))*G.CARD_W*1.1,
                1.05*G.CARD_H, 
                {card_limit = _size, type = 'consumeable', highlight_limit = 1})

            local t = {n=G.UIT.ROOT, config = {align = 'tm', r = 0.15, colour = G.C.CLEAR, padding = 0.15}, nodes={
                {n=G.UIT.R, config={align = "cl", colour = G.C.CLEAR,r=0.15, padding = 0.1, minh = 2, shadow = true}, nodes={
                    {n=G.UIT.R, config={align = "cm"}, nodes={
                    {n=G.UIT.C, config={align = "cm", padding = 0.1}, nodes={
                        {n=G.UIT.C, config={align = "cm", r=0.2, colour = G.C.CLEAR, shadow = true}, nodes={
                            {n=G.UIT.O, config={object = G.pack_cards}},}}}}}},
                {n=G.UIT.R, config={align = "cm"}, nodes={}},
                {n=G.UIT.R, config={align = "tm"}, nodes={
                    {n=G.UIT.C,config={align = "tm", padding = 0.05, minw = 2.4}, nodes={}},
                    {n=G.UIT.C,config={align = "tm", padding = 0.05}, nodes={
                        UIBox_dyn_container({
                            {n=G.UIT.C, config={align = "cm", padding = 0.05, minw = 4}, nodes={
                                {n=G.UIT.R,config={align = "bm", padding = 0.05}, nodes={
                                    {n=G.UIT.O, config={object = DynaText({string = localize(self.group_key or ('k_bunc_blind_pack')), colours = {G.C.WHITE},shadow = true, rotate = true, bump = true, spacing =2, scale = 0.7, maxw = 4, pop_in = 0.5})}}}},
                                {n=G.UIT.R,config={align = "bm", padding = 0.05}, nodes={
                                    {n=G.UIT.O, config={object = DynaText({string = {localize('b_reroll_boss')}, colours = {G.C.WHITE}, shadow = true, rotate = true, bump = true, spacing = 2, scale = 0.5, pop_in = 0.7})}},}},}}
                        }),}},
                    {n=G.UIT.C,config={align = "tm", padding = 0.05, minw = 2.4}, nodes={
                        {n=G.UIT.R,config={minh =0.2}, nodes={}},
                        (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 = {
                            {n=G.UIT.T, config={text = localize('b_skip'), scale = 0.5, colour = G.C.WHITE, shadow = true, focus_args = {button = 'y', orientation = 'bm'}, func = 'set_button_pip'}}}}}}}}}}}}
            return t
        end,

        pos = coordinate_from_atlas_index(i),
        atlas = 'bunco_booster_packs_blind',

        in_pool = function() return G.GAME.used_vouchers['v_bunc_disguise'] end
    }
end

for i = 1, 4 do -- Virtual
    SMODS.Booster{
        type = 'bunc_virtual',

        key = 'virtual_'..(i <= 2 and i or i == 3 and 'jumbo' or 'mega'),

        loc_vars = function(self, info_queue, card)
            return {key = (self.key == 'p_bunc_virtual_1' or self.key == 'p_bunc_virtual_2') and 'p_bunc_virtual_normal' or self.key, vars = {self.config.choose, self.config.extra}}
        end,

        config = {extra = i <= 2 and 2 or 4, choose = i <= 3 and 1 or 2},

        weight = i <= 2 and 0.07 or i == 3 and 0.05 or 0.03,
        get_weight = function(self)
            local new_weight = self.weight * (G.GAME.used_vouchers['v_bunc_arcade_machine'] and 4 or 1)
            return new_weight
        end,

        create_card = function(self, card)
            return create_card('Polymino', G.pack_cards, nil, nil, true, true, nil, 'vir')
            -- return {set = 'Polymino', area = G.pack_cards, skip_materialize = nil, soulable = nil, key_append = 'vir'}
        end,

        create_UIBox = function(self) -- I don't know if I should do it like that, but since I can't inject into steamodded's files directly I do this
            -- However I could mess with the node structure instead of repeating the whole thing. Do you want me to suffer?
            -- Look at this mess. Terrible

            for i = 1, #G.deck.cards do
                draw_card(G.deck, G.hand, i * 100 / #G.deck.cards, 'up', true)
            end

            local _size = SMODS.OPENED_BOOSTER.ability.extra
            G.pack_cards = CardArea(
            G.ROOM.T.x + 9 + G.hand.T.x, G.hand.T.y,
            math.max(1,math.min(_size,5))*G.CARD_W*1.1,
            1.05*G.CARD_H,
            {card_limit = _size, type = 'consumeable', highlight_limit = 1})

            local t = {n=G.UIT.ROOT, config = {align = 'tm', r = 0.15, colour = G.C.CLEAR, padding = 0.15}, nodes={
            {n=G.UIT.R, config={align = "cl", colour = G.C.CLEAR,r=0.15, padding = 0.1, minh = 2, shadow = true}, nodes={
            {n=G.UIT.R, config={align = "cm"}, nodes={
            {n=G.UIT.C, config={align = "cm", padding = 0.1}, nodes={
            {n=G.UIT.C, config={align = "cm", r=0.2, colour = G.C.CLEAR, shadow = true}, nodes={
                {n=G.UIT.O, config={object = G.pack_cards}},}}}}}},
            {n=G.UIT.R, config={align = "cm"}, nodes={}},
            {n=G.UIT.R, config={align = "tm"}, nodes={
            {n=G.UIT.C,config={align = "tm", padding = 0.05, minw = 2.4}, nodes={}},
            {n=G.UIT.C,config={align = "tm", padding = 0.05}, nodes={
            UIBox_dyn_container({
                {n=G.UIT.C, config={align = "cm", padding = 0.05, minw = 4}, nodes={
                    {n=G.UIT.R,config={align = "bm", padding = 0.05}, nodes={
                        {n=G.UIT.O, config={object = DynaText({string = localize(self.group_key or ('k_bunc_virtual_pack')), colours = {G.C.WHITE},shadow = true, rotate = true, bump = true, spacing =2, scale = 0.7, maxw = 4, pop_in = 0.5})}}}},
                    {n=G.UIT.R,config={align = "bm", padding = 0.05}, nodes={
                        {n=G.UIT.O, config={object = DynaText({string = {localize('k_choose')..' '}, colours = {G.C.WHITE}, shadow = true, rotate = true, bump = true, spacing = 2, scale = 0.5, pop_in = 0.7})}},
                        {n=G.UIT.O, config={object = DynaText({string = {{ref_table = G.GAME, ref_value = 'pack_choices'}}, colours = {G.C.WHITE},shadow = true, rotate = true, bump = true, spacing =2, scale = 0.5, pop_in = 0.7})}}}},}}
            }),}},
            {n=G.UIT.C,config={align = "tm", padding = 0.05, minw = 2.4}, nodes={
            {n=G.UIT.R,config={minh =0.2}, nodes={}},
            (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 = {
                {n=G.UIT.T, config={text = localize('b_skip'), scale = 0.5, colour = G.C.WHITE, shadow = true, focus_args = {button = 'y', orientation = 'bm'}, func = 'set_button_pip'}}}}}}}}}}}}
            return t
        end,

        update_pack = function(self, dt)
            SMODS.Booster.update_pack(self)
            if G.STATE_COMPLETE then
                for i = 1, #G.deck.cards do
                    local card = G.deck.cards[i]
                    card.greyed = false
                end
            end
        end,

        ease_background_colour = function(self)
            ease_colour(G.C.DYN_UI.MAIN, G.C.BUNCO_VIRTUAL)
            ease_background_colour{new_colour = HEX('50506a'), special_colour = HEX('7e9999'), contrast = 2}
        end,

        pos = coordinate_from_atlas_index(i),
        atlas = 'bunco_booster_packs_virtual',
    }
end

SMODS.Sound({
    key = 'music_virtual',
    path = 'music_virtual.ogg',
    select_music_track = function(self)
        local booster = G.pack_cards and G.pack_cards.cards and SMODS.OPENED_BOOSTER

        if booster and booster.config.center_key:find('p_bunc_virtual') then
            return 'bunc_music_virtual'
        end
    end
})

-- Enhancements

SMODS.Atlas({key = 'bunco_enhancements', path = 'Enhancements/Enhancements.png', px = 71, py = 95})
SMODS.Sound({key = 'cracker', path = 'cracker.ogg'})

SMODS.Enhancement({ -- Cracker
    key = 'cracker',
    atlas = 'bunco_enhancements', pos = coordinate_from_atlas_index(1)
})

function calculate_cracker_cards(context)
    if #SMODS.find_card('j_bunc_hardtack', false) <= 0 then
        local crackers_total = {}
        for _, cracker_card in ipairs(context.full_hand) do
            if cracker_card.marked_cracker and cracker_card.config.center == G.P_CENTERS.m_bunc_cracker and not cracker_card.debuff then
                if not cracker_card.destroyed then
                    table.insert(crackers_total, cracker_card)

                    forced_message(localize('k_eaten_ex'), cracker_card)

                    local dissolve_time_fac = 2
                    event({
                        trigger = 'before',
                        delay = 0.7*dissolve_time_fac*1.051,
                        func = function()
                            if cracker_card and not cracker_card.removed then

                                play_sound('bunc_cracker', 1.0 + (math.random() * 0.1) - 0.05)

                                local dissolve_time = 0.7*(dissolve_time_fac or 1)
                                local childParts = Particles(0, 0, 0,0, {
                                    timer_type = 'TOTAL',
                                    timer = 0.01 * dissolve_time,
                                    scale = 1.4,
                                    speed = 0.5,
                                    lifespan = 3 * dissolve_time,
                                    attach = cracker_card,
                                    colours = {HEX('fab653'), HEX('ffce7c'), HEX('ffdfaa')},
                                    fill = true
                                })
                                event({
                                    trigger = 'after',
                                    blockable = false,
                                    delay = 0.5 * dissolve_time,
                                    func = (function() 
                                        childParts:fade(0.5 * dissolve_time) 
                                        return true 
                                    end)
                                })

                                cracker_card:start_dissolve({HEX('ffdfaa')}, nil, dissolve_time_fac)
                            end
                            return true
                        end
                    })
                    cracker_card.destroyed = true
                end
            end
        end
        if #crackers_total > 0 then
            SMODS.calculate_context({remove_playing_cards = true, removed = crackers_total})
        end
    end
end

SMODS.Enhancement({ -- Copper
    key = 'copper',
    post_effect = true,
    rescore_amount = 1, pos = coordinate_from_atlas_index(2),
    atlas = 'bunco_enhancements',
    calculate = function(self, card, context, effect)
        if context.post_effect
        and context.cardarea == G.play
        and context.main_scoring
        and context.scoring_hand
        and ((not card.config.copper_rescored_times) or (card.config.copper_rescored_times < card.config.center.rescore_amount)) then

            local card_position
            for position, scoring_card in ipairs(context.scoring_hand) do
                if scoring_card == card then
                    card_position = position
                    break
                end
            end

            local last_in_streak = true
            if context.scoring_hand[card_position + 1] and context.scoring_hand[card_position + 1].config.center == card.config.center and not (context.scoring_hand[card_position + 1].debuff) then
                last_in_streak = false
            end

            if last_in_streak then

                local streak = false
                if context.scoring_hand[card_position - 1] and context.scoring_hand[card_position - 1].config.center == card.config.center and not (context.scoring_hand[card_position - 1].debuff) then
                    streak = true
                end

                if streak then
                    return {
                        func = function()

                            while (card.config.copper_rescored_times or 0) < card.config.center.rescore_amount do

                                local streak_cards = {card}
                                local i = 1

                                while true do
                                    if context.scoring_hand[card_position - i]
                                    and context.scoring_hand[card_position - i].config.center == card.config.center
                                    and not (context.scoring_hand[card_position - i].debuff) then
                                        table.insert(streak_cards, context.scoring_hand[card_position - i])
                                    else
                                        break
                                    end
                                    i = i + 1
                                end

                                for streak_index = #streak_cards, 1, -1 do

                                    local streak_card = streak_cards[streak_index]
                                    event({func = function() big_juice(streak_card) return true end})

                                end

                                play_area_status_text(localize('bunc_repeat'))

                                for streak_index = #streak_cards, 1, -1 do

                                    local streak_card = streak_cards[streak_index]
                                    for _, play_card in ipairs(G.play.cards) do
                                        if play_card == streak_card then
                                            streak_card.config.copper_rescored_times = (streak_card.config.copper_rescored_times or 0) + 1
                                            local passed_context = context
                                            SMODS.score_card(play_card, passed_context)
                                        end
                                    end
                                end

                                SMODS.calculate_context({rescore_cards = streak_cards})
                            end
                        end
                    }
                end
            end
        end
        -- Reset the retrigger thingy
        if context.after and context.scoring_hand then
            for _, other_card in ipairs(context.scoring_hand) do
                other_card.config.copper_rescored_times = 0
            end
        end
    end
})

-- Stickers

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
function Card:calculate_reactive()
    if self.ability.bunc_reactive then
        local skipped_blinds = 0
        for _, v in pairs(G.GAME.round_resets.blind_states) do
            if v == 'Skipped' then
                skipped_blinds = skipped_blinds + 1
            end
        end
        if skipped_blinds == 1 then
            self:juice_up(0.3, 0.3)
        end
    end
end

SMODS.Atlas({key = 'bunco_stickers', path = 'Stickers/Stickers.png', px = 71, py = 95})

SMODS.Sticker{ -- Scattering
    key = 'scattering',

    should_apply = function(self, card, center, area, bypass_roll)
        local default_check = SMODS.Sticker.should_apply(self, card, center, area, bypass_roll)
        local other_sticker_check = not ((card and card.ability) and (card.ability.eternal or card.ability.bunc_hindered or card.ability.bunc_reactive))
        local shop_check = (area == G.shop_jokers) or (area == G.pack_cards)
        return default_check and other_sticker_check and shop_check
    end,
    apply = function(self, card, val)
        -- if card.ability.eternal or card.ability.bunc_hindered or card.ability.bunc_reactive then return end
        card.ability[self.key] = val
        -- card.config.center.eternal_compat = false
    end,

    -- Cross-mod stuff
    compat_exceptions = {
        "sarc_cracked_egg"
    },

    badge_colour = HEX('9eacbe'),

    order = 5,

    pos = coordinate_from_atlas_index(1),
    atlas = 'bunco_stickers'
}

SMODS.Sticker{ -- Hindered
    key = 'hindered',

    should_apply = function(self, card, center, area, bypass_roll)
        local default_check = SMODS.Sticker.should_apply(self, card, center, area, bypass_roll)
        local other_sticker_check = not ((card and card.ability) and (card.ability.eternal or card.ability.bunc_scattering or card.ability.bunc_reactive))
        local shop_check = (area == G.shop_jokers) or (area == G.pack_cards)
        return default_check and other_sticker_check and shop_check
    end,
    apply = function(self, card, val)
        -- if card.ability.eternal or card.ability.bunc_scattering or card.ability.bunc_reactive then return end
        card.ability[self.key] = val
        card.ability.bunc_hindered_sold = false
        -- card.config.center.eternal_compat = false
    end,
    calculate = function(self, card, context)
        if context.end_of_round and not context.repetition and not context.individual then
            card:calculate_hindered()
        end
    end,

    badge_colour = HEX('e97720'),

    order = 6,

    pos = coordinate_from_atlas_index(2),
    atlas = 'bunco_stickers'
}

SMODS.Sticker{ -- Reactive
    key = 'reactive',

    should_apply = function(self, card, center, area, bypass_roll)
        local default_check = SMODS.Sticker.should_apply(self, card, center, area, bypass_roll)
        local other_sticker_check = not ((card and card.ability) and (card.ability.bunc_hindered or card.ability.bunc_scattering))
        local shop_check = (area == G.shop_jokers) or (area == G.pack_cards)
        return default_check and other_sticker_check and shop_check
    end,
    apply = function(self, card, val)
        -- if card.ability.bunc_scattering or card.ability.bunc_hindered then return end
        card.ability[self.key] = val
        if G.GAME and G.GAME.blind then G.GAME.blind:debuff_card(card) end
    end,
    calculate = function(self, card, context)
        if context.skip_blind then
            card:calculate_reactive()
        end
    end,

    badge_colour = HEX('8238c3'),

    order = 7,

    pos = coordinate_from_atlas_index(3),
    atlas = 'bunco_stickers'
}

-- Stakes

SMODS.Atlas({key = 'bunco_stakes', path = 'Stakes/Stakes.png', px = 29, py = 29})
SMODS.Atlas({key = 'bunco_stake_stickers', path = 'Stickers/StickersStake.png', px = 71, py = 95})

SMODS.Stake{ -- Cyan
    key = 'cyan',

    unlocked_stake = 'bunc_pink',
    applied_stakes = {'orange'},
    above_stake = 'orange',
    prefix_config = {above_stake = {mod = false}, applied_stakes = {mod = false}},

    modifiers = function()
        G.GAME.modifiers.enable_bunc_scattering = true
    end,

    loc_vars = function(self)
        local sticker_desc = localize{type="raw_descriptions", key="bunc_scattering", set="Other", vars={}}
        local sticker_desc_string = ""
        for i, v in ipairs(sticker_desc) do
            sticker_desc_string = sticker_desc_string .. v .. " "
        end
        sticker_desc_string = string.sub(sticker_desc_string, 1, -2)

        return {vars = { sticker_desc_string } }
    end,

    colour = HEX('3cd0c8'),

    pos = coordinate_from_atlas_index(1),
    sticker_pos = coordinate_from_atlas_index(1),
    atlas = 'bunco_stakes',
    sticker_atlas = 'bunco_stake_stickers'
}

SMODS.Stake{ -- Pink
    key = 'pink',

    unlocked_stake = 'bunc_magenta',
    applied_stakes = {'bunc_cyan'},
    above_stake = 'bunc_cyan',

    modifiers = function()
        G.GAME.modifiers.enable_bunc_hindered = true
    end,

    loc_vars = function(self)
        local sticker_desc = localize{type="raw_descriptions", key="bunc_hindered", set="Other", vars={}}
        local sticker_desc_string = ""
        for i, v in ipairs(sticker_desc) do
            sticker_desc_string = sticker_desc_string .. v .. " "
        end
        sticker_desc_string = string.sub(sticker_desc_string, 1, -2)

        return {vars = { sticker_desc_string } }
    end,

    colour = HEX('ff8ea4'),

    pos = coordinate_from_atlas_index(2),
    sticker_pos = coordinate_from_atlas_index(2),
    atlas = 'bunco_stakes',
    sticker_atlas = 'bunco_stake_stickers'
}

SMODS.Stake{ -- Magenta
    key = 'magenta',

    unlocked_stake = 'gold',
    applied_stakes = {'bunc_pink'},
    above_stake = 'bunc_pink',

    modifiers = function()
        G.GAME.modifiers.enable_bunc_reactive = true
    end,

    loc_vars = function(self)
        local sticker_desc = localize{type="raw_descriptions", key="bunc_reactive", set="Other", vars={}}
        local sticker_desc_string = ""
        for i, v in ipairs(sticker_desc) do
            sticker_desc_string = sticker_desc_string .. v .. " "
        end
        sticker_desc_string = string.sub(sticker_desc_string, 1, -2)

        return {vars = { sticker_desc_string } }
    end,

    colour = HEX('cd47ea'),

    pos = coordinate_from_atlas_index(3),
    sticker_pos = coordinate_from_atlas_index(3),
    atlas = 'bunco_stakes',
    sticker_atlas = 'bunco_stake_stickers'
}

SMODS.Stake:take_ownership('gold', {
    applied_stakes = {'bunc_magenta'},
    above_stake = 'bunc_magenta'
})


-- Consumable editions in collection
-- These are only for the collection, not for any other in-game use
-- Should have a better way to organise this

local consumable_editions ={
    {key="foil", tag="tag_bunc_chips"},
    {key="holo", tag="tag_bunc_mult"},
    {key="polychrome", tag="tag_bunc_xmult"},
    {key="bunc_glitter", tag="tag_bunc_xchips"}
}

for i, v in ipairs(consumable_editions) do
    SMODS.Edition {
        key = 'e_bunc_consumable_edition_' .. v.key,
        shader = v.key,
        atlas = 'bunco_resprites_tarots',
        pos = { x = 0, y = 0 },
        -- no_collection = true,
        prefix_config = { key = false, shader = false },
        skip_debug = true,
        loc_vars = function(self, info_queue, card)
            info_queue[#info_queue + 1] = {key = v.tag, set = 'Tag', specific_vars = G.P_TAGS[v.tag].loc_vars(self, info_queue).vars}
            -- return {vars = {G.P_CENTERS["e_foil"].loc_vars(self, info_queue, card)}}
        end,
        dependencies = v.dependencies
    }
end


-- Mod compatibility

if _G["JokerDisplay"] then
    filesystem.load(BUNCOMOD.content.path..'compat/jokerdisplay.lua')()
end