Add new Karma Deck; moving old to Ascension Sleeve; moving old to challenge

.editorconfig

@@ -20,11 +20,11 @@ continuation_indent = 4
 
 # this mean utf8 length , if this is 'unset' then the line width is no longer checked
 # this option decides when to chopdown the code
-max_line_length = lf
+max_line_length = 120
 
 # optional crlf/lf/cr/auto, if it is 'auto', in windows it is crlf other platforms are lf
 # in neovim the value 'auto' is not a valid option, please use 'unset' 
-end_of_line = auto
+end_of_line = lf
 
 #  none/ comma / semicolon / only_kv_colon
 table_separator_style = none

assets/shaders/moire.fs

@@ -0,0 +1,151 @@
+#if defined(VERTEX) || __VERSION__ > 100 || defined(GL_FRAGMENT_PRECISION_HIGH)
+	#define MY_HIGHP_OR_MEDIUMP highp
+#else
+	#define MY_HIGHP_OR_MEDIUMP mediump
+#endif
+
+extern MY_HIGHP_OR_MEDIUMP vec2 moire;
+extern MY_HIGHP_OR_MEDIUMP number dissolve;
+extern MY_HIGHP_OR_MEDIUMP number time;
+extern MY_HIGHP_OR_MEDIUMP vec4 texture_details;
+extern MY_HIGHP_OR_MEDIUMP vec2 image_details;
+extern bool shadow;
+extern MY_HIGHP_OR_MEDIUMP vec4 burn_colour_1;
+extern MY_HIGHP_OR_MEDIUMP vec4 burn_colour_2;
+
+vec4 dissolve_mask(vec4 tex, vec2 texture_coords, vec2 uv)
+{
+    if (dissolve < 0.001) {
+        return vec4(shadow ? vec3(0.,0.,0.) : tex.xyz, shadow ? tex.a*0.3: tex.a);
+    }
+
+    float adjusted_dissolve = (dissolve*dissolve*(3.-2.*dissolve))*1.02 - 0.01; //Adjusting 0.0-1.0 to fall to -0.1 - 1.1 scale so the mask does not pause at extreme values
+
+	float t = time * 10.0 + 2003.;
+	vec2 floored_uv = (floor((uv*texture_details.ba)))/max(texture_details.b, texture_details.a);
+    vec2 uv_scaled_centered = (floored_uv - 0.5) * 2.3 * max(texture_details.b, texture_details.a);
+	
+	vec2 field_part1 = uv_scaled_centered + 50.*vec2(sin(-t / 143.6340), cos(-t / 99.4324));
+	vec2 field_part2 = uv_scaled_centered + 50.*vec2(cos( t / 53.1532),  cos( t / 61.4532));
+	vec2 field_part3 = uv_scaled_centered + 50.*vec2(sin(-t / 87.53218), sin(-t / 49.0000));
+
+    float field = (1.+ (
+        cos(length(field_part1) / 19.483) + sin(length(field_part2) / 33.155) * cos(field_part2.y / 15.73) +
+        cos(length(field_part3) / 27.193) * sin(field_part3.x / 21.92) ))/2.;
+    vec2 borders = vec2(0.2, 0.8);
+
+    float res = (.5 + .5* cos( (adjusted_dissolve) / 82.612 + ( field + -.5 ) *3.14))
+    - (floored_uv.x > borders.y ? (floored_uv.x - borders.y)*(5. + 5.*dissolve) : 0.)*(dissolve)
+    - (floored_uv.y > borders.y ? (floored_uv.y - borders.y)*(5. + 5.*dissolve) : 0.)*(dissolve)
+    - (floored_uv.x < borders.x ? (borders.x - floored_uv.x)*(5. + 5.*dissolve) : 0.)*(dissolve)
+    - (floored_uv.y < borders.x ? (borders.x - floored_uv.y)*(5. + 5.*dissolve) : 0.)*(dissolve);
+
+    if (tex.a > 0.01 && burn_colour_1.a > 0.01 && !shadow && res < adjusted_dissolve + 0.8*(0.5-abs(adjusted_dissolve-0.5)) && res > adjusted_dissolve) {
+        if (!shadow && res < adjusted_dissolve + 0.5*(0.5-abs(adjusted_dissolve-0.5)) && res > adjusted_dissolve) {
+            tex.rgba = burn_colour_1.rgba;
+        } else if (burn_colour_2.a > 0.01) {
+            tex.rgba = burn_colour_2.rgba;
+        }
+    }
+
+    return vec4(shadow ? vec3(0.,0.,0.) : tex.xyz, res > adjusted_dissolve ? (shadow ? tex.a*0.3: tex.a) : .0);
+}
+
+number hue(number s, number t, number h)
+{
+	number hs = mod(h, 1.)*6.;
+	if (hs < 1.) return (t-s) * hs + s;
+	if (hs < 3.) return t;
+	if (hs < 4.) return (t-s) * (4.-hs) + s;
+	return s;
+}
+
+vec4 RGB(vec4 c)
+{
+	if (c.y < 0.0001)
+		return vec4(vec3(c.z), c.a);
+
+	number t = (c.z < .5) ? c.y*c.z + c.z : -c.y*c.z + (c.y+c.z);
+	number s = 2.0 * c.z - t;
+	return vec4(hue(s,t,c.x + 1./3.), hue(s,t,c.x), hue(s,t,c.x - 1./3.), c.w);
+}
+
+vec4 HSL(vec4 c)
+{
+	number low = min(c.r, min(c.g, c.b));
+	number high = max(c.r, max(c.g, c.b));
+	number delta = high - low;
+	number sum = high+low;
+
+	vec4 hsl = vec4(.0, .0, .5 * sum, c.a);
+	if (delta == .0)
+		return hsl;
+
+	hsl.y = (hsl.z < .5) ? delta / sum : delta / (2.0 - sum);
+
+	if (high == c.r)
+		hsl.x = (c.g - c.b) / delta;
+	else if (high == c.g)
+		hsl.x = (c.b - c.r) / delta + 2.0;
+	else
+		hsl.x = (c.r - c.g) / delta + 4.0;
+
+	hsl.x = mod(hsl.x / 6., 1.);
+	return hsl;
+}
+
+vec4 effect( vec4 colour, Image texture, vec2 texture_coords, vec2 screen_coords )
+{
+    vec4 tex = Texel(texture, texture_coords);
+	vec2 uv = (((texture_coords)*(image_details)) - texture_details.xy*texture_details.ba)/texture_details.ba;
+
+	number low = min(tex.r, min(tex.g, tex.b));
+    number high = max(tex.r, max(tex.g, tex.b));
+	number delta = high - low;
+
+	number saturation_fac = 1. - max(0., 0.05*(1.1-delta));
+
+	vec4 hsl = HSL(vec4(tex.r*saturation_fac, tex.g*saturation_fac, tex.b, tex.a));
+
+	float t = moire.y*2.221 + mod(time,1.);
+	vec2 floored_uv = (floor((uv*texture_details.ba)))/texture_details.ba;
+    vec2 uv_scaled_centered = (floored_uv - 0.5) * 50.;
+	
+	vec2 field_part1 = uv_scaled_centered + 50.*vec2(sin(-t / 143.6340), cos(-t / 99.4324));
+	vec2 field_part2 = uv_scaled_centered + 50.*vec2(cos( t / 53.1532),  cos( t / 61.4532));
+	vec2 field_part3 = uv_scaled_centered + 50.*vec2(sin(-t / 87.53218), sin(-t / 49.0000));
+
+    float field = (1.+ (
+        cos(length(field_part1) / 19.483) + sin(length(field_part2) / 33.155) * cos(field_part2.y / 15.73) +
+        cos(length(field_part3) / 27.193) * sin(field_part3.x / 21.92) ))/2.;
+
+    float res = (.5 + .5* cos( (moire.x) * 2.612 + ( field + -.5 ) *3.14));
+	hsl.x = length(field_part2);
+	hsl.z = sin(hsl.z/2.5 - res/4. + sin(moire.y)/8. + 0.5)/1.4;
+	
+
+    tex.rgb = RGB(hsl).rgb;
+
+	if (tex[3] < 0.7)
+		tex[3] = tex[3]/3.;
+	return dissolve_mask(tex*colour, texture_coords, uv);
+}
+
+extern MY_HIGHP_OR_MEDIUMP vec2 mouse_screen_pos;
+extern MY_HIGHP_OR_MEDIUMP float hovering;
+extern MY_HIGHP_OR_MEDIUMP float screen_scale;
+
+#ifdef VERTEX
+vec4 position( mat4 transform_projection, vec4 vertex_position )
+{
+    if (hovering <= 0.){
+        return transform_projection * vertex_position;
+    }
+    float mid_dist = length(vertex_position.xy - 0.5*love_ScreenSize.xy)/length(love_ScreenSize.xy);
+    vec2 mouse_offset = (vertex_position.xy - mouse_screen_pos.xy)/screen_scale;
+    float scale = 0.2*(-0.03 - 0.3*max(0., 0.3-mid_dist))
+                *hovering*(length(mouse_offset)*length(mouse_offset))/(2. -mid_dist);
+
+    return transform_projection * vertex_position + vec4(0.,0.,0.,scale);
+}
+#endif

lovely.toml

@@ -48,6 +48,7 @@ payload = '''if Jane and (type(G.ARGS.score_intensity.required_score) == "table"
     local base = Cryptid and 10 or G.ARGS.score_intensity.required_score
     local expo = Cryptid and G.ARGS.score_intensity.required_score or 10
     Jane.sinister = (G.ARGS.score_intensity.earned_score / (big(base) ^ big(expo))):to_number() > 1
+    G.escapey_sinister = Jane.sinister
 end'''
 match_indent = true
 
@@ -57,10 +58,15 @@ target = "functions/state_events.lua"
 pattern = "for _, v in ipairs(SMODS.get_card_areas('playing_cards')) do"
 position = "after"
 payload = '''if v == G.hand and not (G.GAME.blind and G.GAME.blind.name == "The Card" and not G.GAME.blind.disabled) and next(SMODS.find_card("j_jane_survivor")) then
-    for _, v in ipairs(G.hand.cards) do
+    if Cryptid then
-        local area = {cards = {v}}
+        for _, v in ipairs(G.hand.cards) do
-        SMODS.calculate_main_scoring({cardarea = area, full_hand = area.cards, scoring_hand = area.cards, scoring_name = text, poker_hands = poker_hands}, area.cards)
+            local area = {cards = {v}}
-        SMODS.calculate_main_scoring({cardarea = area, full_hand = area.cards, scoring_hand = area.cards, scoring_name = text, poker_hands = poker_hands}, nil)
+            SMODS.calculate_main_scoring({cardarea = area, full_hand = area.cards, scoring_hand = area.cards, scoring_name = text, poker_hands = poker_hands}, area.cards)
+            SMODS.calculate_main_scoring({cardarea = area, full_hand = area.cards, scoring_hand = area.cards, scoring_name = text, poker_hands = poker_hands}, nil)
+        end
+    else
+        SMODS.calculate_main_scoring({cardarea = G.hand, full_hand = G.hand.cards, scoring_hand = G.hand.cards, scoring_name = text, poker_hands = poker_hands}, G.hand.cards)
+        SMODS.calculate_main_scoring({cardarea = G.hand, full_hand = G.hand.cards, scoring_hand = G.hand.cards, scoring_name = text, poker_hands = poker_hands}, nil)
     end
 else'''
 match_indent = true
@@ -122,3 +128,27 @@ pattern = '''hand_chips\*mult\)'''
 position = "at"
 payload = "Jane.get_chipmult_sum(hand_chips, mult))"
 match_indent = true
+
+[[patches]]
+[patches.pattern]
+target = '=[SMODS Cryptid "items/spectral.lua"]'
+pattern = "local _first_dissolve = nil"
+position = "after"
+payload = 'deletable_jokers = next(SMODS.find_card("j_jane_saint")) and {} or deletable_jokers'
+match_indent = true
+
+[[patches]]
+[patches.pattern]
+target = '=[SMODS Cryptid "items/exotic.lua"]'
+pattern = "local _first_dissolve = nil"
+position = "after"
+payload = 'deletable_jokers = next(SMODS.find_card("j_jane_saint")) and {} or deletable_jokers'
+match_indent = true
+
+[[patches]]
+[patches.pattern]
+target = '=[SMODS _ "src/utils.lua"]'
+pattern = "function SMODS.has_enhancement(card, key)"
+position = "after"
+payload = "if not card.config then return false end"
+match_indent = true

manifest.json

@@ -17,5 +17,5 @@
     "conflicts": [
         "Jen"
     ],
-    "version": "1.0.6"
+    "version": "1.5.19"
 }

refs/CardSleeves

@@ -0,0 +1 @@
+../../CardSleeves/

src/back.lua

@@ -5,9 +5,97 @@ SMODS.Atlas {
     path = Jane.config.texture_pack .. "/b_jane_decks.png",
 }
 
-local eternal_text = Cryptid and "Absolute" or "Eternal"
+SMODS.Atlas {
+    px = 73,
+    py = 95,
+    key = "janesleeves",
+    path = Jane.config.texture_pack .. "/sleeve_jane_sleeves.png",
+}
 
-SMODS.Back {
+local function back(x)
+    local key = x.key
+    local apply = x.apply
+    local calculate = x.calculate
+
+    x.apply = function(...)
+        if apply and G.GAME.selected_sleeve ~= "sleeve_jane_" .. key then
+            return apply(...)
+        end
+
+        Jane.q(function()
+            save_run()
+        end)
+    end
+
+    x.calculate = function(...)
+        if calculate and G.GAME.selected_sleeve ~= "sleeve_jane_" .. key then
+            return calculate(...)
+        end
+    end
+
+    SMODS.Back(x)
+    local text = x.loc_txt.text
+    local name = x.loc_txt.name:gsub("Deck$", "Sleeve")
+
+    if not CardSleeves then
+        return
+    end
+
+    G.localization.descriptions.Sleeve = G.localization.descriptions.Sleeve or {}
+    G.localization.descriptions.Sleeve["sleeve_jane_" .. key .. "_alt"] = x.alt_loc_txt
+
+    CardSleeves.Sleeve {
+        key = key,
+        pos = x.pos,
+        atlas = "janesleeves",
+        loc_txt = {name = name, text = text},
+        apply = function(self, ...)
+            -- Game becomes genuinely unplayable if this is allowed.
+            -- if self.get_current_deck_key() == "b_jane_omega" and G.GAME.selected_sleeve == "sleeve_jane_omega" then
+            --     if apply then
+            --         apply(self, ...)
+            --     end
+            --     if x.alt_apply then
+            --         x.alt_apply(self, ...)
+            --     end
+            --     return
+            -- end
+            local a = (self.get_current_deck_key() == "b_jane_" .. key and x.alt_apply or apply)
+
+            if a then
+                a(self, ...)
+            end
+
+            Jane.q(function()
+                save_run()
+            end)
+        end,
+        calculate = function(self, ...)
+            -- Game becomes genuinely unplayable if this is allowed.
+            -- if self.get_current_deck_key() == "b_jane_omega" and G.GAME.selected_sleeve == "sleeve_jane_omega" then
+            --     if calculate then
+            --         calculate(self, ...)
+            --     end
+            --     if x.alt_calculate then
+            --         x.alt_calculate(self, ...)
+            --     end
+            --     return
+            -- end
+            local c = (self.get_current_deck_key() == "b_jane_" .. key and x.alt_calculate or calculate)
+
+            if c then
+                return c(self, ...)
+            end
+        end,
+        loc_vars = function(self, ...)
+            local ret = x.loc_vars and x.loc_vars(self, ...) or {}
+            ret.key = self.get_current_deck_key() == "b_jane_" .. key and self.key .. "_alt" or self.key
+            return ret
+        end,
+    }
+end
+
+back {
     key = "nitro",
     atlas = "janedecks",
     pos = {x = 1, y = 1},
@@ -21,83 +109,111 @@ SMODS.Back {
             Cryptid and "an {C:spectral,E:1}Empowered Tag" or "create a {C:dark_edition}Negative {C:spectral,E:1}Soul",
         },
     },
+    alt_loc_txt = {
+        name = "Jolt Sleeve",
+        text = {
+            Cryptid and "{C:attention}Ante number {}scales with {C:attention}square numbers" or "{C:attention}Ante increases twice{} as strong",
+            "After defeating the {C:attention}Small {}or {C:attention}Big Blind{},",
+            Cryptid and "create a {C:spectral,E:1}Empowered Tag" or "create a {C:dark_edition}Negative {C:spectral,E:1}Soul",
+        },
+    },
     loc_vars = function(_, info_queue, _)
         if info_queue then
-            info_queue[#info_queue + 1] = Cryptid and G.P_CENTERS.c_cry_empowered or G.P_CENTERS.c_soul
+            info_queue[#info_queue + 1] = Cryptid and G.P_TAGS.tag_cry_empowered or G.P_CENTERS.c_soul
         end
 
         return {vars = {}}
     end,
+    alt_apply = function(_)
+        G.GAME.win_ante = Cryptid and G.GAME.win_ante * G.GAME.win_ante or G.GAME.win_ante * 4 - 1
+        G.GAME.alt_nitro = true
+        G.GAME.nitro = true
+    end,
     apply = function(_)
         G.GAME.win_ante = Cryptid and G.GAME.win_ante * (G.GAME.win_ante + 1) / 2 or G.GAME.win_ante * 2 - 1
         G.GAME.nitro = true
     end,
-    trigger_effect = function(_, args)
+    alt_calculate = function(_, _, context)
-        if args.context == "eval" and G.GAME.last_blind and G.GAME.last_blind.boss then
+        if context.end_of_round and not context.individual and not context.repetition and not context.retrigger_joker then
+            Jane.q(function()
+                Jane.empowered()
+            end)
+        end
+    end,
+    calculate = function(_, _, context)
+        if Jane.is_end_of_ante(context) then
             Jane.q(function()
                 Jane.empowered()
-                return true
             end)
         end
     end,
 }
 
+Jane.rain_world_jokers = {
+    "j_jane_monk",
+    "j_jane_survivor",
+    "j_jane_hunter",
+    "j_jane_gourmand",
+    "j_jane_artificer",
+    "j_jane_spearmaster",
+    "j_jane_rivulet",
+    "j_jane_saint",
+    "j_jane_rot",
+}
+
 local function add_rain_world_joker()
     if not G.jokers then
-        return true
+        return
     end
 
-    local candidates = {
-        "j_jane_monk",
-        "j_jane_survivor",
-        "j_jane_hunter",
-        "j_jane_gourmand",
-        "j_jane_artificer",
-        "j_jane_spearmaster",
-        "j_jane_rivulet",
-        "j_jane_saint",
-        "j_jane_rot",
-    }
-
     local unobtained = {}
 
-    for _, v in pairs(candidates) do
+    for _, v in pairs(Jane.rain_world_jokers) do
         if not next(SMODS.find_card(v, true)) then
             unobtained[#unobtained + 1] = v
         end
     end
 
-    local chosen = pseudorandom_element(next(unobtained) and unobtained or candidates, pseudoseed("karma_deck"))
+    local chosen = pseudorandom_element(next(unobtained) and unobtained or Jane.rain_world_jokers,
+        pseudoseed("karma_deck"))
     local card = create_card("Joker", G.jokers, nil, nil, nil, nil, chosen, "karma_deck_next")
     card:add_to_deck()
     card:start_materialize()
     G.jokers:emplace(card)
-    return true
 end
 
-SMODS.Back {
+back {
     key = "karma",
     atlas = "janedecks",
     pos = {x = 3, y = 0},
     loc_txt = {
         name = "Karma Deck",
         text = {
-            "Start with a {C:legendary}Rain World Joker",
+            "Start with a",
-            "Create another when",
+            "{C:legendary}Rain World Joker",
-            "{C:attention}Boss Blind {}is defeated",
         },
     },
-    apply = function(_)
+    alt_loc_txt = {
-        G.E_MANAGER:add_event(Event({func = add_rain_world_joker}))
+        name = "Ascension Sleeve",
+        text = {
+            "Create a {C:legendary}Rain World Joker",
+            "when {C:attention}Boss Blind {}is defeated",
+        },
+    },
+    alt_apply = function(_)
+        Jane.q(add_rain_world_joker)
     end,
-    trigger_effect = function(_, args)
+    apply = function(_)
-        if args.context == "eval" and G.GAME.last_blind and G.GAME.last_blind.boss then
+        Jane.q(add_rain_world_joker)
+    end,
+    alt_calculate = function(_, _, context)
+        if Jane.is_end_of_ante(context) then
             add_rain_world_joker()
         end
     end,
 }
 
-SMODS.Back {
+back {
     key = "mysterious",
     atlas = "janedecks",
     pos = {x = 1, y = 0},
@@ -110,17 +226,45 @@ SMODS.Back {
             "to your possession",
         },
     },
+    alt_loc_txt = {
+        name = "Sleeve?",
+        text = {"{C:attention}Ante order {}is {C:green,E:1}randomized"},
+    },
+    alt_apply = function(_)
+        G.GAME.mysterious = true
+        G.GAME.alt_mysterious = {}
+
+        for i = G.GAME.round_resets.ante + 1, G.GAME.round_resets.ante + G.GAME.win_ante - 1 do
+            G.GAME.alt_mysterious[#G.GAME.alt_mysterious + 1] = {i}
+        end
+
+        pseudoshuffle(G.GAME.alt_mysterious, pseudoseed("mysterious_deck"))
+    end,
     apply = function(_)
         G.GAME.mysterious = true
-
+    end,
-        Jane.q(function()
+    alt_calculate = function(_, _, context)
-            save_run()
+        if context.setting_blind or context.skip_blind then
-            return true
+            G.GAME.mysterious_init = true
-        end)
+        end
+    end,
+    calculate = function(_, _, context)
+        if context.setting_blind or context.skip_blind then
+            G.GAME.mysterious_init = true
+        end
     end,
 }
 
-SMODS.Back {
+local function redeem_omen_globe()
+    G.GAME.used_vouchers.v_omen_globe = true
+    G.GAME.starting_voucher_count = (G.GAME.starting_voucher_count or 0) + 1
+
+    Jane.q(function()
+        Card.apply_to_run(nil, G.P_CENTERS.v_omen_globe)
+    end)
+end
+
+back {
     key = "obsidian",
     atlas = "janedecks",
     pos = {x = 2, y = 1},
@@ -132,6 +276,13 @@ SMODS.Back {
             "Start run with {C:tarot}Omen Globe",
         },
     },
+    alt_loc_txt = {
+        name = "Bedrock Sleeve",
+        text = {
+            "{C:attention}Non-hidden {}cards do",
+            "not {C:attention}normally appear",
+        },
+    },
     loc_vars = function(_, info_queue, _)
         if info_queue then
             info_queue[#info_queue + 1] = G.P_CENTERS.v_omen_globe
@@ -139,18 +290,48 @@ SMODS.Back {
 
         return {vars = {}}
     end,
+    alt_apply = function(_)
+        G.GAME.alt_obsidian = true
+        G.GAME.obsidian = true
+        redeem_omen_globe()
+    end,
     apply = function(_)
         G.GAME.obsidian = true
-        G.GAME.used_vouchers.v_omen_globe = true
+        redeem_omen_globe()
-        G.GAME.starting_voucher_count = (G.GAME.starting_voucher_count or 0) + 1
-
-        Jane.q(function()
-            Card.apply_to_run(nil, G.P_CENTERS.v_omen_globe)
-            return true
-        end)
     end,
 }
 
+local orig_get_current_pool = get_current_pool
+
+---@diagnostic disable-next-line: lowercase-global
+function get_current_pool(_type, ...)
+    local pool, pool_key = orig_get_current_pool(_type, ...)
+
+    if not G.GAME.alt_obsidian or not ({
+            Code = true,
+            Chess = true,
+            Tarot = true,
+            Planet = true,
+            Alphabet = true,
+            Spectral = true,
+            jane_tokens = true,
+        })[_type] then
+        return pool, pool_key
+    end
+
+    for k, _ in pairs(pool) do
+        pool[k] = "UNAVAILABLE"
+    end
+
+    for k, v in pairs(G.P_CENTERS) do
+        if type(v) == "table" and (v.name == "Black Hole" or v.name == "The Soul") or v.hidden then
+            pool[#pool + 1] = k
+        end
+    end
+
+    return pool, pool_key
+end
+
 local function apply_orrery()
     Jane.q(function()
         local orrery = {}
@@ -163,11 +344,84 @@ local function apply_orrery()
         end
 
         save_run()
-        return true
     end)
 end
 
-SMODS.Back {
+local function rebalance_orrery()
+    local function small(x)
+        return type(x) == "table" and x:to_number() or x
+    end
+
+    local function hand(name, chip, mul, lv, notif, snd, vol, pit, de)
+        local config = {
+            delay = de or 0.3,
+            pitch = pit or 0.8,
+            volume = vol or 0.7,
+            sound = type(snd) == "string" and snd or type(snd) == "nil" and "button",
+        }
+
+        local vals = {
+            level = lv or "?",
+            mult = mul or "?",
+            StatusText = notif,
+            chips = chip or "?",
+            handname = name or "????",
+        }
+
+        update_hand_text(config, vals)
+    end
+
+    local orrery = (G.GAME or {}).orrery
+
+    if not orrery then
+        return
+    end
+
+    local count = 0
+    local hands = {}
+    local inequalities = 0
+    local pools = {chips = 0, level = 0, mult = 0}
+
+    for k, v in pairs(G.GAME.hands) do
+        if orrery[k] and
+            (orrery[k].mult ~= v.mult or
+                orrery[k].chips ~= v.chips or
+                orrery[k].level ~= v.level) then
+            inequalities = inequalities + 1
+        end
+
+        count = count + 1
+        hands[#hands + 1] = v
+        pools.mult = v.mult + pools.mult
+        pools.chips = v.chips + pools.chips
+        pools.level = v.level + pools.level
+    end
+
+    if inequalities == 0 then
+        return
+    end
+
+    pools.chips = pools.chips + inequalities * 150
+    table.sort(hands, function(x, y) return x.order > y.order end)
+
+    for i, v in ipairs(hands) do
+        v.mult = math.floor(pools.mult / count) + (small(pools.mult % count) >= i and 1 or 0)
+        v.chips = math.floor(pools.chips / count) + (small(pools.chips % count) >= i and 1 or 0)
+        v.level = math.floor(pools.level / count) + (small(pools.level % count) >= i and 1 or 0)
+    end
+
+    for k, v in pairs(G.GAME.hands) do
+        orrery[k] = {chips = v.chips, level = v.level, mult = v.mult}
+    end
+
+    hand(localize("k_all_hands"), math.floor(pools.chips / count), math.floor(pools.mult / count),
+        math.floor(pools.level / count))
+    delay(1)
+    update_hand_text({sound = "button", volume = 0.7, pitch = 1.1, delay = 0},
+        {mult = 0, chips = 0, handname = "", level = ""})
+end
+
+back {
     key = "orrery",
     atlas = "janedecks",
     pos = {x = 0, y = 0},
@@ -178,12 +432,58 @@ SMODS.Back {
             "always " .. (Cryptid and "{C:cry_ascendant}" or "{C:attention}") .. "equalized",
         },
     },
+    alt_loc_txt = {
+        name = "Ephemeris Sleeve",
+        text = {
+            "{C:blue}Hands{}, {C:red}discards{}, and {C:money}money",
+            "are always " .. (Cryptid and "{C:cry_ascendant}" or "{C:attention}") .. "equalized",
+        },
+    },
+    alt_apply = function(_)
+        apply_orrery()
+    end,
     apply = function(_)
         apply_orrery()
     end,
+    calculate = rebalance_orrery,
+    alt_calculate = function(_, _, context)
+        local function small(x)
+            return type(x) == "table" and x:to_number() or x
+        end
+
+        if context.setting_blind or context.skip_blind then
+            G.GAME.alt_orrery = true
+        end
+
+        if not G.GAME.alt_orrery then
+            return
+        end
+
+        local dollars = G.GAME.dollars
+        local hands = G.GAME.current_round.hands_left
+        local discards = G.GAME.current_round.discards_left
+        local sum = hands + discards + dollars
+        local new_dollars = math.floor(sum / 3) - dollars
+        local new_hands = small(math.floor((sum + 2) / 3)) - hands
+        local new_discards = small(math.floor((sum + 1) / 3)) - discards
+
+        if new_dollars ~= 0 then
+            ease_dollars(new_dollars, true)
+        end
+
+        if new_hands ~= 0 then
+            ease_hands_played(new_hands, true)
+        end
+
+        if new_discards ~= 0 then
+            ease_discard(new_discards, true)
+        end
+
+        rebalance_orrery()
+    end,
 }
 
-SMODS.Back {
+back {
     key = "tortoise",
     atlas = "janedecks",
     pos = {x = 3, y = 1},
@@ -194,6 +494,17 @@ SMODS.Back {
             "{C:attention}half{} as strong",
         },
     },
+    alt_loc_txt = {
+        name = "Sleepy Sleeve",
+        text = {
+            "{C:attention}Ante {}changes",
+            "are {C:attention}inverted",
+        },
+    },
+    alt_apply = function(_)
+        G.GAME.tortoise = true
+        G.GAME.alt_tortoise = true
+    end,
     apply = function(_)
         G.GAME.tortoise = true
     end,
@@ -203,6 +514,10 @@ local function apply_weeck()
     G.GAME.weeck = true
 
     Jane.q(function()
+        if G.GAME.selected_sleeve == "sleeve_jane_omega" then
+            return
+        end
+
         local new_card = create_card("Joker", G.jokers, nil, nil, nil, nil, "j_wee", "weeck")
         new_card.ability.cry_absolute = true
         new_card.ability.eternal = true
@@ -229,29 +544,89 @@ local function apply_weeck()
         end
 
         save_run()
-        return true
     end)
 end
 
-SMODS.Back {
+local function two(x)
+    if type(x) ~= "table" then
+        return
+    end
+
+    for k, v in pairs(x) do
+        if type(v) == "number" then
+            x[k] = x[k] == 0 and 0 or 2
+        elseif type(v) == "table" then
+            two(v)
+        end
+    end
+end
+
+local eternal_text = Cryptid and "Absolute" or "Eternal"
+
+back {
     key = "weeck",
     atlas = "janedecks",
     pos = {x = 4, y = 1},
     loc_txt = {
         name = "Weeck",
-        text = {
+        text = Cryptid and {
             "Start with an {C:purple,E:1}" .. eternal_text,
             "{C:attention}Wee Joker {}and a deck",
             "containing {C:attention}2 {C:purple,E:1}" .. eternal_text,
             "{C:attention}2's {}of {C:attention}each suit",
+        } or {
+            "Start with an {C:purple,E:1}" .. eternal_text,
+            "{C:attention}Wee Joker {}and a deck",
+            "of {C:attention}2 2's {}of {C:attention}each suit",
         },
     },
+    alt_loc_txt = {
+        name = "We",
+        text = {
+            "Every stat and",
+            "card number is {C:attention}2",
+            "{C:inactive}(If possible)",
+        },
+    },
+    alt_apply = function(_)
+        local p = G.GAME.starting_params
+        p.hands = 2
+        p.dollars = 2
+        p.discards = 2
+        G.GAME.skips = 2
+        p.joker_slots = 2
+        p.reroll_cost = 2
+        G.GAME.sunlevel = 2
+        p.boosters_in_shop = 2
+        p.consumable_slots = 2
+        p.vouchers_in_shop = 2
+
+        for _, v in pairs(G.GAME.hands) do
+            v.mult = 2
+            v.chips = 2
+            v.level = 2
+        end
+
+        apply_weeck()
+    end,
     apply = function(_)
         apply_weeck()
     end,
+    alt_calculate = function(_)
+        if not G.GAME.we then
+            G.GAME.we = true
+            G.hand.config.highlighted_limit = 2
+            G.hand:change_size(2 - G.hand.config.card_limit)
+        end
+    end,
 }
 
-SMODS.Back {
+local banned_keys = {
+    sleeve_Seen_Seen = true,
+    sleeve_jane_omega = true,
+}
+
+back {
     key = "omega",
     atlas = "janedecks",
     pos = {x = 5, y = 1},
@@ -262,33 +637,55 @@ SMODS.Back {
             "of {C:attention}every Jane deck",
         },
     },
+    alt_loc_txt = {
+        name = "Epsilon Sleeve",
+        text = {
+            "Applies {X:red,C:white}all{} effects of",
+            "{C:attention}every deck and sleeve",
+            "{X:black,C:red,E:2,s:2}UNPLAYABLE",
+        },
+    },
+    alt_apply = function(_, ...)
+        if (Bakery_API or {}).create_charm_area then
+            Bakery_API.create_charm_area()
+        end
+
+        for _, v in pairs(G.P_CENTERS) do
+            if v.apply and not banned_keys[v.key] and (v.set == "Back" or v.set == "Sleeve") then
+                v:apply(...)
+            end
+        end
+    end,
     apply = function(_)
         apply_orrery()
         G.GAME.used_vouchers.v_omen_globe = true
         G.GAME.starting_voucher_count = (G.GAME.starting_voucher_count or 0) + 1
 
-        G.E_MANAGER:add_event(Event({
+        Jane.q(function()
-            func = function()
+            local wee = create_card("Joker", G.jokers, nil, nil, nil, nil, "j_wee", "weeck")
-                local wee = create_card("Joker", G.jokers, nil, nil, nil, nil, "j_wee", "weeck")
+            G.jokers:emplace(wee)
-                G.jokers:emplace(wee)
+            add_rain_world_joker()
-                add_rain_world_joker()
+            G.GAME.tortoise = true
-                G.GAME.tortoise = true
+            G.GAME.obsidian = true
-                G.GAME.obsidian = true
+            G.GAME.mysterious = true
-                G.GAME.mysterious = true
+            save_run()
-                save_run()
+        end)
-                return true
-            end,
-        }))
     end,
-    trigger_effect = function(_, args)
+    alt_calculate = function(_, ...)
+        for _, v in pairs(G.P_CENTERS) do
+            if v.calculate and not banned_keys[v.key] and (v.set == "Back" or v.set == "Sleeve") then
+                v:calculate(...)
+            end
+        end
+    end,
+    calculate = function(_, _, context)
         G.GAME.mysterious = nil
 
-        if args.context == "eval" and G.GAME.last_blind and G.GAME.last_blind.boss then
+        if Jane.is_end_of_ante(context) then
             add_rain_world_joker()
 
             Jane.q(function()
                 Jane.empowered()
-                return true
             end)
         end
     end,
@@ -298,15 +695,36 @@ local orig_ante = ease_ante
 
 ---@diagnostic disable-next-line: lowercase-global
 function ease_ante(mod)
-    local function next_triangle_number(x)
+    local function next_number(x)
+        if G.GAME.alt_nitro then
+            local n = math.sqrt(x) + 1
+            return n * n
+        end
+
         local n = (math.sqrt(8 * x + 1) - 1) / 2
         return (n + 1) * (n + 2) / 2
     end
 
+    if G.GAME.alt_mysterious then
+        if not next(G.GAME.alt_mysterious) then
+            G.GAME.alt_mysterious = {}
+
+            for i = G.GAME.round_resets.ante + 1, G.GAME.round_resets.ante + G.GAME.win_ante do
+                G.GAME.alt_mysterious[#G.GAME.alt_mysterious + 1] = {i}
+            end
+
+            pseudoshuffle(G.GAME.alt_mysterious, pseudoseed("mysterious_deck"))
+        end
+
+        local target = G.GAME.alt_mysterious[#G.GAME.alt_mysterious][1]
+        G.GAME.alt_mysterious[#G.GAME.alt_mysterious] = nil
+        mod = target - G.GAME.round_resets.ante
+    end
+
     if G.GAME.nitro then
         mod = Cryptid and
             (G.GAME.round_resets.ante < 0 and -G.GAME.round_resets.ante or
-                math.ceil(next_triangle_number(G.GAME.round_resets.ante) - G.GAME.round_resets.ante)) or
+                math.ceil(next_number(G.GAME.round_resets.ante) - G.GAME.round_resets.ante)) or
             (mod > 0 and mod * 2 or mod)
     end
 
@@ -321,6 +739,10 @@ function ease_ante(mod)
         mod = math.floor(mod / 2) + remainder
     end
 
+    if G.GAME.alt_tortoise then
+        mod = mod * -1
+    end
+
     orig_ante(mod)
 end
 
@@ -364,7 +786,6 @@ function CardArea:emplace(card, location, stay_flipped)
                 end
 
                 c:juice_up(0.3, 0.3)
-                return true
             end
         end
 
@@ -378,26 +799,23 @@ function CardArea:emplace(card, location, stay_flipped)
             end
         else
             for i = 1, #targets do
-                G.E_MANAGER:add_event(Event({
+                Jane.q(function()
-                    trigger = "after",
+                    targets[i]:flip()
-                    delay = 0.15,
+                    play_sound("card1", 1.15 - (i - 0.999) / (#G.hand.cards - 0.998) * 0.3)
-                    func = function()
+                    targets[i]:juice_up(0.3, 0.3)
-                        targets[i]:flip()
+                end, 0.15)
-                        play_sound("card1", 1.15 - (i - 0.999) / (#G.hand.cards - 0.998) * 0.3)
+
-                        targets[i]:juice_up(0.3, 0.3)
+                Jane.q(function()
-                        return true
+                    targets[i]:flip()
-                    end,
+                    play_sound("card1", 1.15 - (i - 0.999) / (#G.hand.cards - 0.998) * 0.3)
-                }))
+                    targets[i]:juice_up(0.3, 0.3)
+                end, 0.15)
             end
 
             delay(0.2)
 
             for i = 1, #targets do
-                G.E_MANAGER:add_event(Event({
+                Jane.q(go(i), 0.1)
-                    trigger = "after",
-                    delay = 0.1,
-                    func = go(i),
-                }))
             end
         end
     end
@@ -422,9 +840,8 @@ function CardArea:emplace(card, location, stay_flipped)
             passes = 0
             pooling = false
             tries = tries - 1
-
+            local sd = pseudoseed(seed or "jane_rnd_mysterious")
-            selection = G.P_CENTERS
+            selection = G.P_CENTERS[pseudorandom_element(pool or G.P_CENTER_POOLS.Consumeables, sd).key]
-                [pseudorandom_element(pool or G.P_CENTER_POOLS.Consumeables, pseudoseed(seed or "jane_rnd_mysterious")).key]
 
             if ignore_pooling then
                 pooling = true
@@ -453,11 +870,13 @@ function CardArea:emplace(card, location, stay_flipped)
         G.deck and
         G.consumeables and
         (self == G.jokers or self == G.hand or self == G.deck or self == G.consumeables) and
-        G.GAME.mysterious and card.ability and not
+        G.GAME.mysterious and
+        card.ability and not
         card.ability.mysterious_created and not
         card.created_from_split then
         card.ability.mysterious_created = true
         local cen = card.gc and card:gc()
+
         if cen then
             if self == G.jokers then
                 Jane.q(function()
@@ -471,8 +890,6 @@ function CardArea:emplace(card, location, stay_flipped)
                         card:juice_up(0.3, 0.3)
                         play_sound("card1", 1, 0.6)
                     end
-
-                    return true
                 end, 0.75)
 
                 delay(0.75)
@@ -488,8 +905,6 @@ function CardArea:emplace(card, location, stay_flipped)
                             card:add_to_deck()
                         end
                     end
-
-                    return true
                 end, 0.75)
             elseif self == G.consumeables then
                 Jane.q(function()
@@ -503,8 +918,6 @@ function CardArea:emplace(card, location, stay_flipped)
                         card:juice_up(0.3, 0.3)
                         play_sound("card1", 1, 0.6)
                     end
-
-                    return true
                 end, 0.75)
 
                 delay(0.75)
@@ -516,18 +929,17 @@ function CardArea:emplace(card, location, stay_flipped)
                         play_sound("card3", 1, 0.6)
 
                         card:set_ability(
-                            rnd("mysterious_deck_consumable", cen.hidden and {} or {"hidden"}, G.P_CENTER_POOLS[cen.set])
+                            rnd("mysterious_deck_consumable", cen.hidden and {} or {"hidden"},
+                                G.P_CENTER_POOLS[cen.set])
                         )
 
                         if not card.added_to_deck then
                             card:add_to_deck()
                         end
                     end
-
-                    return true
                 end, 0.75)
             elseif (card.base or {}).value or (card.base or {}).suit then
-                randomize({card})
+                randomize({card}, not G.GAME.mysterious_init)
             end
         end
 
@@ -535,10 +947,12 @@ function CardArea:emplace(card, location, stay_flipped)
             if card and self then
                 orig_emplace(self, card, location, stay_flipped)
             end
-
-            return true
         end)
     else
         orig_emplace(self, card, location, stay_flipped)
+
+        if G.GAME.we then
+            two(card.ability)
+        end
     end
 end

src/blind.lua

@@ -53,8 +53,6 @@ local function offset_operator(by)
         if changed_text then
             play_sound("button", 1.1, 0.65)
         end
-
-        return true
     end)
 end
 
@@ -144,9 +142,16 @@ SMODS.Blind {
     pos = {x = 0, y = 3},
     vars = {},
     dollars = 2,
-    debuff_hand = function(_, cards, _, _, _)
+    disable = function(self)
+        self.disabled = true
+    end,
+    debuff_hand = function(self, cards, _, _, _)
+        if self.disabled then
+            return false
+        end
+
         for _, v in ipairs(cards) do
-            if v:norank() or v:get_id() ~= 2 then
+            if (v:norank() or v:get_id() ~= 2) and (v.ability or {}).aikoyori_letters_stickers ~= "2" then
                 return true
             end
         end
@@ -154,8 +159,10 @@ SMODS.Blind {
     get_loc_debuff_text = function(_)
         return "Hand must contain only 2s"
     end,
-    recalc_debuff = function(_, card, _)
+    recalc_debuff = function(self, card, _)
-        return card:norank() or card:get_id() ~= 2
+        return not self.disabled and
+            (card:norank() or card:get_id() ~= 2) and
+            (card.ability or {}).aikoyori_letters_stickers ~= "2"
     end,
     set_blind = function(self)
         if to_number(self.mult) == 0 then

src/challenge.lua

@@ -0,0 +1,78 @@
+local is_rain_world_joker = {}
+
+for _, v in pairs(Jane.rain_world_jokers) do
+    is_rain_world_joker[v] = true
+end
+
+SMODS.Challenge {
+    key = "downpour",
+    loc_txt = {
+        name = "Downpour",
+    },
+    rules = {custom = {
+        {id = "jane_downpour1"},
+        {id = "jane_downpour2"},
+        {id = "jane_downpour3"},
+        {id = "jane_downpour4"},
+    }},
+    apply = function(_)
+        G.GAME.win_ante = 16
+
+        for _, v in ipairs(Jane.rain_world_jokers) do
+            Jane.q(function()
+                local card = create_card("Joker", G.jokers, nil, nil, nil, nil, v, "karma_deck_next")
+                card:add_to_deck()
+                card:start_materialize()
+                G.jokers:emplace(card)
+                play_sound("timpani")
+            end, 0.2)
+        end
+    end,
+    calculate = function(_, context)
+        local function l()
+            if G.STAGE == G.STAGES.RUN then
+                G.STATE = G.STATES.GAME_OVER
+                G.STATE_COMPLETE = false
+            end
+        end
+
+        if not Jane.is_end_of_ante(context) then
+            return
+        end
+
+        local destructible_jokers = {}
+
+        for _, v in pairs(G.jokers.cards) do
+            if is_rain_world_joker[v.config.center.key] and not ((v.ability or {}).eternal or (v.ability or {}).cry_absolute) then
+                destructible_jokers[#destructible_jokers + 1] = v
+            end
+        end
+
+        if not next(destructible_jokers) then
+            return l()
+        end
+
+        local chosen = pseudorandom_element(destructible_jokers, pseudoseed("karma_deck"))
+
+        if chosen then
+            chosen.getting_sliced = true
+            chosen:start_dissolve()
+        end
+    end,
+}
+
+G.localization.misc.v_text["ch_c_jane_downpour1"] = {
+    "Start with all {C:legendary}Rain World Jokers",
+}
+
+G.localization.misc.v_text["ch_c_jane_downpour2"] = {
+    "Destroy a random {C:legendary}Rain World Joker {}when",
+}
+
+G.localization.misc.v_text["ch_c_jane_downpour3"] = {
+    "{C:attention}Boss Blind {}is defeated, or {C:red}lose",
+}
+
+G.localization.misc.v_text["ch_c_jane_downpour4"] = {
+    "Win on {C:attention}Ante 16",
+}

src/edition.lua

@@ -1,44 +1,57 @@
-SMODS.Sound({key = "e_jumbo", path = "e_jumbo.ogg"})
+SMODS.Shader({key = "moire", path = "moire.fs"})
 SMODS.Shader({key = "polygloss", path = "polygloss.fs"})
+SMODS.Sound({key = "e_jumbo", path = "e_jumbo.ogg"})
+SMODS.Sound({key = "e_moire", path = "e_moire.ogg"})
 SMODS.Sound({key = "e_polygloss", path = "e_polygloss.ogg"})
 
+local function allow_moire()
+    if Cryptid then
+        return true
+    end
+
+    for _, v in pairs(SMODS.find_card("j_jane_saint")) do
+        if v.ability.extra.is_attuned then
+            return true
+        end
+    end
+
+    return false
+end
+
+local function get_weight(self)
+    return G.GAME.edition_rate * self.weight * (allow_moire() and 1 or 0)
+end
+
 SMODS.Edition({
     key = "polygloss",
     loc_txt = {
         name = "Polygloss",
         label = "Polygloss",
         text = Cryptid and {
-            "{C:chips}+#1#{}, {X:chips,C:white}x#2#{} & {X:chips,C:dark_edition}^#3#{} Chips",
+            "{C:chips}+#1#{} Chips",
-            "{C:mult}+#4#{}, {X:mult,C:white}x#5#{} & {X:mult,C:dark_edition}^#6#{} Mult",
+            "{C:mult}+#2#{}, {X:mult,C:white}X#3#{}, & {X:mult,C:dark_edition}^#4#{} Mult",
-            "{C:money}$#7# {}when scored",
-        } or {
-            "{C:chips}+#1#{} & {X:chips,C:white}x#2#{}",
-            "{C:mult}+#3#{} & {X:mult,C:white}x#4#{}",
             "{C:money}$#5# {}when scored",
+        } or {
+            "{C:chips}+#1#{} Chips",
+            "{C:mult}+#2#{} & {X:mult,C:white}X#3#{} Mult",
+            "{C:money}$#4# {}when scored",
         },
     },
     config = {
-        mult = 1,
+        mult = 2,
-        chips = 1,
+        chips = 12,
-        x_mult = 1.1,
+        x_mult = 1.2,
-        x_chips = 1.1,
         p_dollars = 1,
-        e_chips = Cryptid and 1.01 or nil,
+        e_mult = Cryptid and 1.02 or nil,
-        e_mult = Cryptid and 1.01 or nil,
-    },
-    sound = {
-        sound = "jane_e_polygloss",
-        per = 1.2,
-        vol = 0.4,
     },
+    sound = {sound = "jane_e_polygloss", per = 1.2, vol = 0.4},
     weight = 8,
     extra_cost = 4,
     in_shop = true,
     shader = "polygloss",
     apply_to_float = false,
-    loc_vars = function(self)
+    loc_vars = function(self, _, _)
-        local vars = {self.config.chips, self.config.x_chips}
+        local vars = {self.config.chips}
-        vars[#vars + 1] = self.config.e_chips
         vars[#vars + 1] = self.config.mult
         vars[#vars + 1] = self.config.x_mult
         vars[#vars + 1] = self.config.e_mult
@@ -55,8 +68,6 @@ SMODS.Edition({
             return {
                 e_mult = card.edition.e_mult,
                 x_mult = card.edition.x_mult,
-                e_chips = card.edition.e_chips,
-                x_chips = card.edition.x_chips,
                 p_dollars = card.edition.p_dollars,
             }
         elseif context.main_scoring and context.cardarea == G.play then
@@ -65,14 +76,21 @@ SMODS.Edition({
                 chips = card.edition.chips,
                 e_mult = card.edition.e_mult,
                 x_mult = card.edition.x_mult,
-                e_chips = card.edition.e_chips,
-                x_chips = card.edition.x_chips,
                 p_dollars = card.edition.p_dollars,
             }
         end
     end,
+    get_weight = get_weight,
 })
 
+local orig_draw_shader = Sprite.draw_shader
+
+function Sprite:draw_shader(_shader, ...)
+    if _shader ~= "jane_jumbo" then
+        return orig_draw_shader(self, _shader, ...)
+    end
+end
+
 local jumbo_modifier = Cryptid and 100 or 2
 
 SMODS.Edition({
@@ -88,14 +106,9 @@ SMODS.Edition({
         },
     },
     on_apply = function(card)
-        G.E_MANAGER:add_event(Event({
+        Jane.q(function()
-            blocking = false,
+            Jane.resize(card, Jane.config.wee_sizemod)
-            blockable = false,
+        end, nil, nil, nil, false, false)
-            func = function()
-                Jane.resize(card, Jane.config.wee_sizemod)
-                return true
-            end,
-        }))
 
         local obj = card:gc()
 
@@ -114,14 +127,9 @@ SMODS.Edition({
         end
     end,
     on_remove = function(card)
-        G.E_MANAGER:add_event(Event({
+        Jane.q(function()
-            blocking = false,
+            Jane.resize(card, 1 / Jane.config.wee_sizemod)
-            blockable = false,
+        end, nil, nil, nil, false, false)
-            func = function()
-                Jane.resize(card, 1 / Jane.config.wee_sizemod)
-                return true
-            end,
-        }))
 
         local was_added = card.added_to_deck
 
@@ -135,18 +143,42 @@ SMODS.Edition({
             card:add_to_deck()
         end
     end,
-    config = {twos_scored = 0},
+    sound = {sound = "jane_e_jumbo", per = 1, vol = 0.5},
-    sound = {
+    weight = 4,
-        sound = "jane_e_jumbo",
+    extra_cost = 5,
-        per = 1,
-        vol = 0.5,
-    },
-    weight = 0.8,
     in_shop = true,
     shader = false,
-    extra_cost = 5,
+    apply_to_float = false,
+    get_weight = get_weight,
+})
+
+SMODS.Edition({
+    key = "moire",
+    loc_txt = {
+        name = "Moire",
+        label = "Moire",
+        text = {
+            "{X:chips,C:dark_edition}^#1#{C:chips} Chips",
+            "{X:mult,C:dark_edition}^#2#{C:mult} Mult",
+        },
+    },
+    config = {e_chips = Cryptid and 0.8 or 0.9, e_mult = Cryptid and 1.2 or 1.1},
+    sound = {sound = "jane_e_moire", per = 1, vol = 0.7},
+    weight = 2,
+    extra_cost = 6,
+    in_shop = true,
+    shader = "moire",
+    in_pool = allow_moire,
     apply_to_float = false,
     get_weight = function(self)
         return G.GAME.edition_rate * self.weight
     end,
+    loc_vars = function(self, _, _)
+        return {vars = {self.config.e_chips, self.config.e_mult}}
+    end,
+    calculate = function(self, _, context)
+        if context.post_joker or context.main_scoring and context.cardarea == G.play then
+            return {e_chips = self.config.e_chips, e_mult = self.config.e_mult}
+        end
+    end,
 })

src/joker.lua

@@ -70,7 +70,6 @@ local function grand_dad(card)
 
     Jane.q(function()
         card:juice_up(0.5, 0.5)
-        return true
     end)
 
     local rnd = math.random(6)
@@ -128,6 +127,8 @@ local maxie_quotes = {
     },
 }
 
+local maxie_limit = 25
+
 SMODS.Joker {
     key = "maxie",
     atlas = "janemaxie",
@@ -155,8 +156,11 @@ SMODS.Joker {
         }
     end,
     calculate = function(_, card, context)
+        local min = math.min(card.ability.extra.choices, maxie_limit)
+        card.ability.extra.choices = min
+
         if context.starting_shop then
-            for _ = 1, card.ability.extra.choices do
+            for _ = 1, min do
                 SMODS.add_booster_to_shop()
             end
         end
@@ -358,7 +362,7 @@ function Jane.oxy(card, removed)
     end
 end
 
-local steel = 1.5
+local steel = 2
 
 SMODS.Joker {
     key = "oxy",
@@ -366,15 +370,15 @@ SMODS.Joker {
     loc_txt = {
         name = "Oxy{C:dark_edition}#1#",
         text = {
-            "{C:attention}Scored steel {}cards give",
+            "{C:attention}Scored steel {}cards",
-            "{X:mult,C:white}x#2#{} {C:mult}Mult {}and {X:chips,C:white}x#2#{} {C:chips}Chips",
+            "give {X:mult,C:white}X#2#{} {C:mult}Mult",
             "{C:dark_edition,E:1}#3#{}#4#{C:red}#5#{C:attention}#6#",
             "{C:dark_edition,E:1}#7#{}#8#",
             "#9#{C:dark_edition,E:1}#10#",
             "{C:inactive,s:0.75,E:1}#11#{C:red,s:1.5,E:1}#12#",
         },
     },
-    config = {extra = {corrupted_steel = 2.5, is_corrupted = false, milestone = 3, progress = 0}},
+    config = {extra = {corrupted_steel = 6, is_corrupted = false, milestone = 3, progress = 0}},
     pos = {x = 0, y = 0},
     sinis = {x = 2, y = 0},
     soul_pos = {x = 1, y = 0},
@@ -449,34 +453,26 @@ SMODS.Joker {
                 (extra.progress <= 0 and extra.is_corrupted)) then
             extra.is_corrupting = true
 
-            G.E_MANAGER:add_event(Event({
+            Jane.q(function()
-                delay = 0.1,
+                card:flip()
-                func = function()
+                play_sound("card1")
-                    card:flip()
+            end, 0.1)
-                    play_sound("card1")
-                    return true
-                end,
-            }))
 
-            G.E_MANAGER:add_event(Event({
+            Jane.q(function()
-                delay = 1,
+                card:flip()
-                func = function()
+                card:juice_up(1, 1)
-                    card:flip()
+                play_sound("card1")
-                    card:juice_up(1, 1)
+                play_sound("jane_corrupt_milestone")
-                    play_sound("card1")
+                extra.is_corrupted = not extra.is_corrupted
-                    play_sound("jane_corrupt_milestone")
+                extra.is_corrupting = nil
-                    extra.is_corrupted = not extra.is_corrupted
+            end, 1)
-                    extra.is_corrupting = nil
-                    return true
-                end,
-            }))
         end
 
         if context.individual and
             context.cardarea == G.play and
             context.other_card.ability.name == "Steel Card" then
             local amount = extra.is_corrupted and extra.corrupted_steel or steel
-            return {x_chips = amount, x_mult = amount, colour = G.C.PURPLE, card = card}, true
+            return {x_mult = amount, colour = G.C.PURPLE, card = card}, true
         end
     end,
 }
@@ -486,6 +482,7 @@ if Cryptid then
 end
 
 local operator = Cryptid and "^" or "X"
+local operator_prefix = Cryptid and "{X:dark_edition,C:mult}" or "{X:mult,C:white}"
 
 SMODS.Joker {
     key = "betmma",
@@ -493,12 +490,12 @@ SMODS.Joker {
     loc_txt = {
         name = "Betmma",
         text = {
-            "{X:dark_edition,C:chips}+" .. operator .. "#1#{C:chips} Chips{} for every",
+            operator_prefix .. "+" .. operator .. "#1#{C:mult} Mult{} for every",
             "{C:attention}unique Voucher redeemed",
-            "{C:inactive}(Currently {X:dark_edition,C:chips}" .. operator .. "#2#{C:inactive})",
+            "{C:inactive}(Currently " .. operator_prefix .. operator .. "#2#{C:inactive})",
         },
     },
-    config = {big_num_scaler = true, extra = {tet = Cryptid and 0.1 or 0.25}},
+    config = {extra = {tet = Cryptid and 0.25 or 0.5}},
     pos = {x = 0, y = 0},
     soul_pos = {x = 1, y = 0},
     blueprint_compat = true,
@@ -521,7 +518,7 @@ SMODS.Joker {
                 card = card,
                 colour = G.C.jane_RGB,
                 message = operator .. number_format(num),
-                [Cryptid and "e_chips" or "x_chips"] = num,
+                [Cryptid and "e_mult" or "x_mult"] = num,
             }, true
         end
     end,
@@ -561,7 +558,7 @@ SMODS.Joker {
             if context.other_card and context.other_card:get_id() == 7 and scj(context) then
                 grand_dad(card)
                 local palette = granddad_palette[math.random(#granddad_palette)]
-                local rnd = pseudorandom(pseudoseed("granddad"), 1, Cryptid and 7 or 5)
+                local rnd = pseudorandom(pseudoseed("granddad"), 1, Cryptid and 5 or 4)
 
                 if rnd == 1 then
                     return {
@@ -586,25 +583,11 @@ SMODS.Joker {
                     }, true
                 elseif rnd == 4 then
                     return {
-                        message = Cryptid and "x7" or "x1.77",
+                        message = Cryptid and "X7 Mult" or "X1.77 Mult",
-                        x_chips = Cryptid and 7 or 1.77,
-                        colour = palette,
-                        card = card,
-                    }, true
-                elseif rnd == 5 then
-                    return {
-                        message = Cryptid and "x7 Mult" or "x1.77 Mult",
                         x_mult = Cryptid and 7 or 1.77,
                         colour = palette,
                         card = card,
                     }, true
-                elseif rnd == 6 then
-                    return {
-                        message = "^1.77",
-                        e_chips = 1.77,
-                        colour = palette,
-                        card = card,
-                    }, true
                 else
                     return {
                         message = "^1.77 Mult",
@@ -624,28 +607,29 @@ SMODS.Joker {
     loc_txt = {
         name = "Peppino Spaghetti",
         text = {
-            "{X:dark_edition,C:red}" .. operator .. "2^x{C:red} Mult{} for every",
+            operator_prefix .. operator .. "2^x{C:red} Mult{} for every",
             "{C:attention}food or Peppino Joker",
             "in your possession",
-            "{C:inactive}(Currently {X:dark_edition,C:red}" .. operator .. "#1#{C:red} Mult{C:inactive})",
+            "{C:inactive}(Currently " .. operator_prefix .. operator .. "#1#{C:red} Mult{C:inactive})",
         },
     },
     pos = {x = 0, y = 0},
     soul_pos = {x = 1, y = 0},
+    config = {extra = {base = 2}},
     rarity = exotic,
     blueprint_compat = true,
     cost = Cryptid and 50 or 20,
-    loc_vars = function(_, _, _)
+    loc_vars = function(_, _, card)
-        return {vars = {2 ^ food_jokers_count()}}
+        return {vars = {card.ability.extra.base ^ food_jokers_count()}}
     end,
-    calculate = function(_, _, context)
+    calculate = function(_, card, context)
         local count = food_jokers_count()
 
         if context.joker_main and count > 0 then
             return {
                 colour = G.C.DARK_EDITION,
-                message = operator .. 2 ^ count .. " Mult",
+                message = operator .. card.ability.extra.base ^ count .. " Mult",
-                [Cryptid and "e_mult" or "x_mult"] = 2 ^ count,
+                [Cryptid and "e_mult" or "x_mult"] = card.ability.extra.base ^ count,
             }, true
         end
     end,

src/main.lua

@@ -41,7 +41,7 @@ function Jane.card_status_text(
     sound,
     volume,
     pitch,
-    trig,
+    trigger,
     f
 )
     if (delay or 0) <= 0 then
@@ -75,10 +75,8 @@ function Jane.card_status_text(
             G.ROOM.jiggle = G.ROOM.jiggle + jiggle
         end
     else
-        G.E_MANAGER:add_event(Event({
+        Jane.q(
-            trigger = trig,
+            function()
-            delay = delay,
-            func = function()
                 if f and type(f) == "function" then
                     f(card)
                 end
@@ -108,17 +106,18 @@ function Jane.card_status_text(
                 if jiggle then
                     G.ROOM.jiggle = G.ROOM.jiggle + jiggle
                 end
-
-                return true
             end,
-        }))
+            delay,
+            nil,
+            trigger
+        )
     end
 end
 
 function Jane.empowered()
     if Cryptid then
         add_tag(Tag("tag_cry_empowered"))
-        return true
+        return
     end
 
     local card = create_card("Spectral", G.consumeables, nil, nil, nil, nil, "c_soul", "acceleration_soul")
@@ -153,25 +152,25 @@ function Jane.get_operator()
     return math.max(math.min(G.GAME.operator, 3), 1)
 end
 
-function Jane.get_small_chipmult_sum(chips, mult)
+function Jane.hidden(card)
-    local ret = Jane.get_chipmult_sum()
+    return G.GAME and not G.GAME.obsidian and
-    return type(ret) == "table" and ret:to_number() or ret
+        (type(card) == "table" and (card.name == "Black Hole" or card.name == "The Soul") or card.hidden)
 end
 
-function Jane.hidden(card)
+function Jane.is_end_of_ante(context, card)
-    return G.GAME and not
+    return not context.individual and not
-        G.GAME.obsidian and
+        context.repetition and not
-        type(card) == "table" and
+        (card or {}).debuff and
-        (card.name == "Black Hole" or card.name == "The Soul" or card.hidden)
+        context.end_of_round and not
+        context.blueprint and
+        G.GAME.blind.boss and not
+        (G.GAME.blind.config and G.GAME.blind.config.bonus)
 end
 
 function Jane.play_sound(sound, per, vol)
-    G.E_MANAGER:add_event(Event({
+    Jane.q(function()
-        func = function()
+        play_sound(sound, per, vol)
-            play_sound(sound, per, vol)
+    end)
-            return true
-        end,
-    }))
 end
 
 function Jane.resize(card, mod, force_save)
@@ -193,14 +192,17 @@ function Jane.resize(card, mod, force_save)
     end
 end
 
-function Jane.q(fc, de, t, tr, bl, ba)
+function Jane.q(func, delay, timer, trigger, blockable, blocking)
     G.E_MANAGER:add_event(Event({
-        timer = t,
+        delay = delay,
-        trigger = tr,
+        timer = timer,
-        delay = de,
+        trigger = (delay and not trigger) and "after" or trigger,
-        blockable = bl,
+        blocking = blocking,
-        blocking = ba,
+        blockable = blockable,
-        func = fc,
+        func = function(...)
+            local ret = func(...)
+            return ret == nil and true or ret
+        end,
     }))
 end
 
@@ -216,17 +218,6 @@ function Card:nosuit()
     return self.ability.name == "Stone Card" or self.config.center.no_suit
 end
 
-local orig_debuff = Card.set_debuff
-
-function Card:set_debuff(should_debuff)
-    if should_debuff and ((self.config or {}).center or {}).debuff_immune then
-        Jane.card_status_text(self, "Immune", nil, 0.05 * self.T.h, G.C.RED, nil, 0.6, nil, nil, "bm", "cancel", 1, 0.9)
-        return false
-    else
-        orig_debuff(self, should_debuff)
-    end
-end
-
 local orig_menu = Game.main_menu
 
 function Game:main_menu(change_context)
@@ -249,82 +240,10 @@ function Game:update(dt)
         end
     end
 
-    local function hand(name, chip, mul, lv, notif, snd, vol, pit, de)
-        local config = {
-            delay = de or 0.3,
-            pitch = pit or 0.8,
-            volume = vol or 0.7,
-            sound = type(snd) == "string" and snd or type(snd) == "nil" and "button",
-        }
-
-        local vals = {
-            level = lv or "?",
-            mult = mul or "?",
-            StatusText = notif,
-            chips = chip or "?",
-            handname = name or "????",
-        }
-
-        update_hand_text(config, vals)
-    end
-
-    local function rebalance_orrery()
-        local function small(x)
-            return type(x) == "table" and x:to_number() or x
-        end
-
-        local orrery = (G.GAME or {}).orrery
-
-        if not orrery then
-            return
-        end
-
-        local count = 0
-        local hands = {}
-        local inequalities = 0
-        local pools = {chips = 0, level = 0, mult = 0}
-
-        for k, v in pairs(G.GAME.hands) do
-            if orrery[k] and
-                (orrery[k].mult ~= v.mult or
-                    orrery[k].chips ~= v.chips or
-                    orrery[k].level ~= v.level) then
-                inequalities = inequalities + 1
-            end
-
-            count = count + 1
-            hands[#hands + 1] = v
-            pools.mult = v.mult + pools.mult
-            pools.chips = v.chips + pools.chips
-            pools.level = v.level + pools.level
-        end
-
-        if inequalities == 0 then
-            return
-        end
-
-        pools.chips = pools.chips + inequalities * 150
-        table.sort(hands, function(x, y) return x.order > y.order end)
-
-        for i, v in ipairs(hands) do
-            v.mult = math.floor(pools.mult / count) + (small(pools.mult % count) >= i and 1 or 0)
-            v.chips = math.floor(pools.chips / count) + (small(pools.chips % count) >= i and 1 or 0)
-            v.level = math.floor(pools.level / count) + (small(pools.level % count) >= i and 1 or 0)
-        end
-
-        for k, v in pairs(G.GAME.hands) do
-            orrery[k] = {chips = v.chips, level = v.level, mult = v.mult}
-        end
-
-        hand(localize("k_all_hands"), math.floor(pools.chips / count), math.floor(pools.mult / count),
-            math.floor(pools.level / count))
-        delay(1)
-        update_hand_text({sound = "button", volume = 0.7, pitch = 1.1, delay = 0},
-            {mult = 0, chips = 0, handname = "", level = ""})
-    end
-
     local function hsv(h, s, v)
-        if s <= 0 then return v, v, v end
+        if s <= 0 then
+            return v, v, v
+        end
 
         h = h * 6
         local c = v * s
@@ -349,7 +268,6 @@ function Game:update(dt)
     end
 
     orig_update(self, dt)
-
     local ante = G.GAME.round_resets.ante
     local blind = get_blind_amount((ante >= 1 and ante <= 8) and math.floor(ante) or ante)
     G.P_BLINDS["bl_jane_wee"].mult = 22 / blind
@@ -357,8 +275,8 @@ function Game:update(dt)
     Jane.update_honey()
 
     if not Jane.bans_done then
-        delete_hardbans()
         Jane.bans_done = true
+        delete_hardbans()
     end
 
     if (G.GAME or {}).banned_keys then
@@ -375,18 +293,6 @@ function Game:update(dt)
         self.C.jane_RGB_HUE = (self.C.jane_RGB_HUE + 0.5) % 360
         G.ARGS.LOC_COLOURS.jane_RGB = self.C.jane_RGB
     end
-
-    rebalance_orrery()
-end
-
-local orig_card = SMODS.find_card
-
----@param key string
----@param count_debuffed true?
----@return Card[]|table[]
---- Returns all cards matching provided `key`.
-function SMODS.find_card(key, count_debuffed)
-    return orig_card(key == "j_jen_saint" and "j_jane_saint" or key, count_debuffed)
 end
 
 SMODS.Atlas {
@@ -407,6 +313,7 @@ for _, v in ipairs({
     "back",
     "blind",
     "booster",
+    "challenge",
     "edition",
     "joker",
     "slugcat",

src/slugcat.lua

@@ -5,6 +5,36 @@ for i = 1, 8 do
     SMODS.Sound({key = "gore" .. i, path = "gore" .. i .. ".ogg"})
 end
 
+SMODS.Sound({
+    key = "music_attuned",
+    path = "music_attuned.ogg",
+    volume = 1,
+    select_music_track = function()
+        for _, v in pairs(SMODS.find_card("j_jane_saint")) do
+            if v.ability.extra.is_attuned then
+                return Jane.sinister and -1 / 0 or 10
+            end
+        end
+
+        return -1 / 0
+    end,
+})
+
+SMODS.Sound({
+    key = "music_attuned_sinister",
+    path = "music_attuned_sinister.ogg",
+    volume = 1,
+    select_music_track = function()
+        for _, v in pairs(SMODS.find_card("j_jane_saint")) do
+            if v.ability.extra.is_attuned then
+                return Jane.sinister and 10 or -1 / 0
+            end
+        end
+
+        return -1 / 0
+    end,
+})
+
 for _, v in pairs({
     "artificer",
     "hunter",
@@ -34,6 +64,8 @@ SMODS.Rarity {
     badge_colour = G.C.JOKER_GREY,
 }
 
+local monk_limit = 25
+
 SMODS.Joker {
     key = "monk",
     atlas = "janemonk",
@@ -74,11 +106,14 @@ SMODS.Joker {
             return
         end
 
+        local min = math.min(card.ability.extra.retriggers, monk_limit)
+        card.ability.extra.retriggers = min
+
         return {
-            message = localize("k_again_ex"),
-            repetitions = card.ability.extra.retriggers,
-            colour = G.C.ORANGE,
             card = card,
+            repetitions = min,
+            colour = G.C.ORANGE,
+            message = localize("k_again_ex"),
         }, true
     end,
 }
@@ -90,9 +125,9 @@ SMODS.Joker {
         name = "The Survivor",
         text = {
             "All cards held in hand",
-            "{C:attention}contribute to scoring {}and",
+            "{C:attention}contribute to scoring" .. (Cryptid and " {}and" or ""),
-            "are all considered as",
+            Cryptid and "are all considered as" or nil,
-            "the {C:attention}first played card",
+            Cryptid and "the {C:attention}first played card" or nil,
         },
     },
     pos = {x = 0, y = 0},
@@ -121,8 +156,8 @@ SMODS.Joker {
     eternal_compat = false,
     perishable_compat = false,
     soul_pos = {x = 1, y = 0},
-    cost = Cryptid and 20 or 8,
+    cost = Cryptid and 15 or 8,
-    rarity = Cryptid and 4 or 3,
+    rarity = Cryptid and epic or 3,
     loc_vars = function(_, info_queue, card)
         local function rounds(amount)
             return " round" .. ((math.abs(amount) > 1 or math.abs(amount) == 0) and "s" or "")
@@ -157,6 +192,7 @@ SMODS.Joker {
         local function spawn_rot()
             card:flip()
             card:juice_up(2, 0.8)
+            card.getting_sliced = true
             Jane.card_status_text(card, "Dead!", nil, 0.05 * card.T.h, G.C.BLACK, 2, 0, 0, nil, "bm", "jane_gore6")
 
             Jane.q(function()
@@ -166,24 +202,19 @@ SMODS.Joker {
                 card:set_eternal(nil)
                 card2:set_eternal(true)
                 play_sound("jane_gore5")
-                return true
             end)
-        end
-
-        local function die()
-            spawn_rot()
-
-            Jane.q(function()
-                Jane.empowered()
-                return true
-            end, 0.1)
 
             Jane.q(function()
                 card:start_dissolve()
-                return true
             end, 1)
+        end
 
-            return true
+        local function die()
+            Jane.q(function()
+                Jane.empowered()
+            end, 0.1)
+
+            spawn_rot()
         end
 
         if context.blueprint then
@@ -199,17 +230,13 @@ SMODS.Joker {
 
             if not card.hunter_prep then
                 card.hunter_prep = true
+
                 Jane.q(function()
-                    Jane.q(function()
+                    card.hunter_prep = nil
-                        card.hunter_prep = nil
-                        if G.GAME.current_round.hands_left < G.GAME.round_resets.hands then
-                            ease_hands_played(G.GAME.round_resets.hands - G.GAME.current_round.hands_left)
-                        end
 
-                        return true
+                    if G.GAME.current_round.hands_left < G.GAME.round_resets.hands then
-                    end)
+                        ease_hands_played(G.GAME.round_resets.hands - G.GAME.current_round.hands_left)
-
+                    end
-                    return true
                 end)
             end
 
@@ -254,7 +281,7 @@ SMODS.Joker {
             else
                 card:juice_up(2, 0.8)
                 Jane.play_sound("jane_warning_heartbeat")
-                G.E_MANAGER:add_event(Event({trigger = "after", func = die}))
+                Jane.q(die, 0)
             end
         end
     end,
@@ -331,6 +358,8 @@ SMODS.Joker {
     end,
 }
 
+local spearmaster_limit = 25
+
 SMODS.Joker {
     key = "spearmaster",
     atlas = "janespearmaster",
@@ -342,10 +371,13 @@ SMODS.Joker {
             "{C:attention}Booster Packs{} have {C:green}+#1#{} additional cards",
         },
     },
-    loc_vars = function(_, _, center)
+    config = {extra = {choices = 1}},
-        return {vars = {center.ability.extra.extrachoices}}
+    loc_vars = function(_, _, card)
+        return {vars = {card.ability.extra.choices}}
+    end,
+    calculate = function(_, card, _)
+        card.ability.extra.choices = math.min(card.ability.extra.choices, spearmaster_limit)
     end,
-    config = {extra = {extrachoices = 1}},
     pos = {x = 0, y = 0},
     soul_pos = {x = 1, y = 0},
     cost = Cryptid and 12 or 20,
@@ -361,7 +393,7 @@ function Card:open()
 
     if next(spearmasters) then
         for _, v in pairs(spearmasters) do
-            orig = orig + v.ability.extra.extrachoices
+            orig = orig + v.ability.extra.choices
         end
 
         self.config.choose = math.floor(orig)
@@ -370,17 +402,11 @@ function Card:open()
 
     orig_open(self)
 
-    G.E_MANAGER:add_event(Event({
+    Jane.q(function()
-        delay = 0.5,
+        if next(spearmasters) then
-        timer = "REAL",
+            G.GAME.pack_choices = math.floor(self.ability.extra)
-        func = function()
+        end
-            if next(spearmasters) then
+    end, 0.5, "REAL")
-                G.GAME.pack_choices = math.floor(self.ability.extra)
-            end
-
-            return true
-        end,
-    }))
 end
 
 SMODS.Joker {
@@ -431,7 +457,20 @@ function Card:draw(layer)
     orig_draw(self, layer)
 end
 
-local attune = Cryptid and 1.001 or 1.1
+local orig_debuff = Card.set_debuff
+
+function Card:set_debuff(should_debuff)
+    if should_debuff and ((self.config or {}).center or {}).debuff_immune then
+        Jane.card_status_text(self, "Immune", nil, 0.05 * self.T.h, G.C.RED, nil, 0.6, nil, nil, "bm", "cancel", 1, 0.9)
+        return false
+    else
+        orig_debuff(self, should_debuff)
+    end
+end
+
+local function attunement()
+    return (G.GAME or {}).weeckweeck and 2 or (Cryptid and 1.002 or 1.2)
+end
 
 SMODS.Joker {
     key = "saint",
@@ -439,9 +478,10 @@ SMODS.Joker {
     loc_txt = {
         name = "The Saint{C:jane_RGB}#1#",
         text = Cryptid and {
-            "{C:spectral}Ankh and Gateway {}will {C:attention}not destroy Jokers",
+            "{C:spectral}Analog{}, {C:spectral}Ankh{}, {C:spectral}Gateway{}, and",
-            "{C:jane_RGB}#2#{}#3#{X:black,C:jane_RGB,s:1.5}#4#{C:spectral}#5#{C:chips}#6#{}#7#{C:mult}#8#",
+            "{C:spectral,s:0.95}Summoning {s:0.95}will {C:attention,s:0.95}not destroy Jokers",
-            "{C:inactive,s:1.25}#9#{C:attention,s:1.25}#10#{C:inactive,s:1.25}#11#{C:inactive}#12#",
+            "{C:jane_RGB}#2#{}#3#{X:black,C:jane_RGB,s:1.5}#4#{C:spectral}#5#{C:mult}#6#",
+            "{C:inactive,s:1.25}#7#{C:attention,s:1.25}#8#{C:inactive,s:1.25}#9#{C:inactive}#10#",
         } or {
             "{C:spectral}Ankh {}will {C:attention}not destroy Jokers",
             "{C:jane_RGB}#2#{}#3#{C:dark_edition}#4#{C:spectral}#5#",
@@ -455,8 +495,17 @@ SMODS.Joker {
     rarity = 4,
     blueprint_compat = true,
     loc_vars = function(_, info_queue, card)
+        if Cryptid then
+            info_queue[#info_queue + 1] = G.P_CENTERS.c_cry_analog
+        end
+
         info_queue[#info_queue + 1] = G.P_CENTERS.c_ankh
         info_queue[#info_queue + 1] = Cryptid and G.P_CENTERS.c_cry_gateway or G.P_CENTERS.c_soul
+
+        if Cryptid then
+            info_queue[#info_queue + 1] = G.P_CENTERS.c_cry_summoning
+        end
+
         local extra = card.ability.extra
         local karma = extra.karma
         local max_karma = extra.max_karma
@@ -467,11 +516,9 @@ SMODS.Joker {
                 attuned and " (Attuned)" or "",
                 attuned and "" or "Attune ",
                 attuned and "" or "after using ",
-                attuned and "^^" .. attune or max_karma,
+                attuned and "^^" .. attunement() or max_karma,
                 attuned and "" or " Gateways",
-                attuned and " Chips " or "",
+                attuned and " Mult" or "",
-                attuned and "& " or "",
-                attuned and "Mult" or "",
                 attuned and "" or "[",
                 attuned and "" or karma,
                 attuned and "" or " / " .. max_karma .. "]",
@@ -479,7 +526,7 @@ SMODS.Joker {
             } or {
                 attuned and " (Attuned)" or "",
                 attuned and "" or "Attune ",
-                attuned and "Fires on cards with " or "after using ",
+                attuned and "Boosts cards with " or "after using ",
                 attuned and "editions" or max_karma,
                 attuned and "" or " Ankh or Soul Cards",
                 attuned and "" or "[",
@@ -490,6 +537,8 @@ SMODS.Joker {
         }
     end,
     update = function(_, card, _)
+        card.debuff_immune = card.ability.extra.is_attuned
+
         if card.added_to_deck and card.children.center and card.children.floating_sprite then
             local extra = card.ability.extra
             card.children.floating_sprite:set_sprite_pos({x = extra.is_attuned and 2 or 1, y = 0})
@@ -498,7 +547,41 @@ SMODS.Joker {
     calculate = function(_, card, context)
         local extra = card.ability.extra
         local max_karma = extra.max_karma
-        extra.is_attuned = extra.karma >= max_karma
+        extra.is_attuned = extra.is_attuned and extra.karma >= max_karma
+
+        local function ascend()
+            if extra.is_attuning then
+                return
+            end
+
+            extra.is_attuning = true
+
+            Jane.card_status_text(
+                card,
+                "!!!",
+                nil,
+                0.05 * card.T.h,
+                G.C.DARK_EDITION,
+                0.6,
+                0.6,
+                2,
+                2,
+                "bm",
+                "jane_enlightened"
+            )
+
+            Jane.q(function()
+                card:flip()
+                play_sound("card1")
+            end, 0.1)
+
+            Jane.q(function()
+                card:flip()
+                card:juice_up(1, 1)
+                play_sound("card1")
+                extra.is_attuned = true
+            end, 1)
+        end
 
         if extra.is_attuned then
             card.debuff = false
@@ -508,28 +591,42 @@ SMODS.Joker {
                 card.ability.perish_tally = 1e9
             end
 
-            if ({[false] = context.cardarea ~= G.play, [true] = not context.joker_main})[not not Cryptid] then
+            if Cryptid and not context.joker_main then
                 return
             end
 
+            if not Cryptid and not context.other_joker and (not context.individual or context.cardarea ~= G.play) then
+                return
+            end
+
+            local attune = attunement()
+
             local trigger = ({
-                e_holo = {mult_mod = 50},
+                e_holo = {mult = 50},
-                e_foil = {chip_mod = 250},
+                e_foil = {chips = 250},
-                e_polychrome = {xmult_mod = 2.5},
+                e_polychrome = {x_mult = 2.5},
                 e_jane_polygloss = {
+                    mult = 10,
+                    x_mult = 2,
+                    chips = 100,
+                    p_dollars = 10,
+                },
+                e_jane_moire = {
                     colour = G.C.jane_RGB,
                     sound = "talisman_eeechip",
                     [Cryptid and "EEchip_mod" or "Echip_mod"] = attune,
                     [Cryptid and "EEmult_mod" or "Emult_mod"] = attune,
                     message = (Cryptid and "^^" or "^") .. attune .. " Chips & Mult",
                 },
-            })[Cryptid and "e_jane_polygloss" or ((context.other_card or {}).edition or {}).key]
+            })[Cryptid and "e_jane_moire" or ((context.other_card or context.other_joker or {}).edition or {}).key]
 
             if trigger then
                 trigger.card = card
             end
 
             return trigger
+        elseif extra.karma >= max_karma then
+            ascend()
         end
 
         if not (not context.blueprint and
@@ -570,39 +667,7 @@ SMODS.Joker {
             return
         end
 
-        Jane.card_status_text(
+        ascend()
-            card,
-            "!!!",
-            nil,
-            0.05 * card.T.h,
-            G.C.DARK_EDITION,
-            0.6,
-            0.6,
-            2,
-            2,
-            "bm",
-            "jane_enlightened"
-        )
-
-        G.E_MANAGER:add_event(Event({
-            delay = 0.1,
-            func = function()
-                card:flip()
-                play_sound("card1")
-                return true
-            end,
-        }))
-
-        G.E_MANAGER:add_event(Event({
-            delay = 1,
-            func = function()
-                card:flip()
-                card:juice_up(1, 1)
-                play_sound("card1")
-                extra.is_attuned = true
-                return true
-            end,
-        }))
     end,
 }
 
@@ -640,32 +705,22 @@ SMODS.Joker {
             return G.jokers.config.card_count < G.jokers.config.card_limit
         end
 
-        local function is_end_of_ante()
-            return not context.individual and not
-                context.repetition and not
-                card.debuff and
-                context.end_of_round and not
-                context.blueprint and
-                G.GAME.blind.boss and not
-                (G.GAME.blind.config and G.GAME.blind.config.bonus)
-        end
-
         local function spawn()
+            if card.cloned then
+                return
+            end
+
             local rot = copy_card(card)
             rot.cloned = true
             rot:add_to_deck()
             G.jokers:emplace(rot)
             Jane.card_status_text(rot, "...", nil, 0.05 * card.T.h, G.C.BLACK, 3, 0, 0, nil, "bm")
-            return true
         end
 
-        if has_room() and not card.cloned and is_end_of_ante() then
+        if has_room() and not card.cloned and Jane.is_end_of_ante(context, card) then
             Jane.q(spawn, 0.5)
         else
-            Jane.q(function()
+            card.cloned = false
-                card.cloned = false
-                return true
-            end, 5)
         end
     end,
 }

src/spectral.lua

@@ -12,61 +12,51 @@ local function conjure(card, number)
         math.ceil(card.ability.extra.spectrals) * number,
         G.consumeables.config.card_limit - #G.consumeables.cards
     ) do
-        G.E_MANAGER:add_event(Event({
+        Jane.q(function()
-            trigger = "after",
+            if G.consumeables.config.card_limit <= #G.consumeables.cards then
-            delay = 0.4,
+                return
-            func = function()
+            end
-                if G.consumeables.config.card_limit <= #G.consumeables.cards then
-                    return true
-                end
 
-                play_sound("jane_draw")
+            play_sound("jane_draw")
-                local spectral = create_card("Spectral", G.consumeables, nil, nil, nil, nil, nil, "pri")
+            local spectral = create_card("Spectral", G.consumeables, nil, nil, nil, nil, nil, "pri")
-                spectral:add_to_deck()
+            spectral:add_to_deck()
-                G.consumeables:emplace(spectral)
+            G.consumeables:emplace(spectral)
-                card:juice_up(0.3, 0.5)
+            card:juice_up(0.3, 0.5)
-                return true
+        end, 0.4)
-            end,
-        }))
     end
 end
 
-local function createfulldeck(enhancement, edition, amount, emplacement)
+local function create_full_deck(enhancement, edition, amount, emplacement)
     local cards = {}
 
     for _, v in pairs(G.P_CARDS) do
-        for i = 1, (amount or 1) do
+        for i = 1, amount or 1 do
-            G.E_MANAGER:add_event(Event({
+            Jane.q(function()
-                delay = 0.1,
+                cards[i] = true
-                func = function()
+                G.playing_card = (G.playing_card and G.playing_card + 1) or 1
-                    cards[i] = true
-                    G.playing_card = (G.playing_card and G.playing_card + 1) or 1
 
-                    local card = Card(
+                local card = Card(
-                        G.play.T.x + G.play.T.w / 2,
+                    G.play.T.x + G.play.T.w / 2,
-                        G.play.T.y, G.CARD_W, G.CARD_H,
+                    G.play.T.y, G.CARD_W, G.CARD_H,
-                        v,
+                    v,
-                        enhancement or G.P_CENTERS.c_base,
+                    enhancement or G.P_CENTERS.c_base,
-                        {playing_card = G.playing_card}
+                    {playing_card = G.playing_card}
-                    )
+                )
 
-                    if edition then
+                if edition then
-                        card:set_edition(type(edition) == "table" and edition or {[edition] = true}, true, true)
+                    card:set_edition(type(edition) == "table" and edition or {[edition] = true}, true, true)
-                    end
+                end
 
-                    play_sound("card1")
+                play_sound("card1")
-                    table.insert(G.playing_cards, card)
+                table.insert(G.playing_cards, card)
-                    card:add_to_deck()
+                card:add_to_deck()
 
-                    if emplacement then
+                if emplacement then
-                        emplacement:emplace(card)
+                    emplacement:emplace(card)
-                    else
+                else
-                        G.deck:emplace(card)
+                    G.deck:emplace(card)
-                    end
+                end
-
+            end, 0.1)
-                    return true
-                end,
-            }))
         end
     end
 
@@ -74,13 +64,6 @@ local function createfulldeck(enhancement, edition, amount, emplacement)
         if next(cards) then
             playing_card_joker_effects(cards)
         end
-
-        return true
-    end)
-
-    Jane.q(function()
-        cards = nil
-        return true
     end)
 end
 
@@ -125,16 +108,11 @@ local function randomize(targets, noanim)
         for i = 1, #targets do
             local percent = 1.15 - (i - 0.999) / (#G.hand.cards - 0.998) * 0.3
 
-            G.E_MANAGER:add_event(Event({
+            Jane.q(function()
-                trigger = "after",
+                targets[i]:flip()
-                delay = 0.15,
+                play_sound("card1", percent)
-                func = function()
+                targets[i]:juice_up(0.3, 0.3)
-                    targets[i]:flip()
+            end, 0.15)
-                    play_sound("card1", percent)
-                    targets[i]:juice_up(0.3, 0.3)
-                    return true
-                end,
-            }))
         end
 
         delay(0.2)
@@ -142,39 +120,34 @@ local function randomize(targets, noanim)
         for i = 1, #targets do
             local percent = 0.85 + (i - 0.999) / (#G.hand.cards - 0.998) * 0.3
 
-            G.E_MANAGER:add_event(Event({
+            Jane.q(function()
-                trigger = "after",
+                local card = targets[i]
-                delay = 0.1,
+                card:set_base(pseudorandom_element(G.P_CARDS))
-                func = function()
+                card:set_ability(pseudorandom_element(G.P_CENTER_POOLS["Enhanced"]))
-                    local card = targets[i]
-                    card:set_base(pseudorandom_element(G.P_CARDS))
-                    card:set_ability(pseudorandom_element(G.P_CENTER_POOLS["Enhanced"]))
 
-                    local edition_rate = 2
+                local edition_rate = 2
-                    card:set_edition(poll_edition("standard_edition" .. G.GAME.round_resets.ante, edition_rate, true))
+                card:set_edition(poll_edition("standard_edition" .. G.GAME.round_resets.ante, edition_rate, true))
-                    local seal_rate = 10
+                local seal_rate = 10
-                    local seal_poll = pseudorandom(pseudoseed("stdseal" .. G.GAME.round_resets.ante))
+                local seal_poll = pseudorandom(pseudoseed("stdseal" .. G.GAME.round_resets.ante))
 
-                    if seal_poll > 1 - 0.02 * seal_rate then
+                if seal_poll > 1 - 0.02 * seal_rate then
-                        local seal_type = pseudorandom(pseudoseed("stdsealtype" .. G.GAME.round_resets.ante))
+                    local seal_type = pseudorandom(pseudoseed("stdsealtype" .. G.GAME.round_resets.ante))
-                        local seal_list = {}
+                    local seal_list = {}
 
-                        for k, _ in pairs(G.P_SEALS) do
+                    for k, _ in pairs(G.P_SEALS) do
-                            table.insert(seal_list, k)
+                        table.insert(seal_list, k)
-                        end
-
-                        seal_type = math.floor(seal_type * #seal_list)
-                        card:set_seal(seal_list[seal_type])
-                    else
-                        card:set_seal()
                     end
 
-                    card:flip()
+                    seal_type = math.floor(seal_type * #seal_list)
-                    play_sound("card3", percent, 0.6)
+                    card:set_seal(seal_list[seal_type])
-                    card:juice_up(0.3, 0.3)
+                else
-                    return true
+                    card:set_seal()
-                end,
+                end
-            }))
+
+                card:flip()
+                play_sound("card3", percent, 0.6)
+                card:juice_up(0.3, 0.3)
+            end, 0.1)
         end
     end
 end
@@ -197,15 +170,10 @@ SMODS.Consumable {
         return Jane.can_use() and #((G.hand or {}).cards or {}) > 0
     end,
     use = function(_, card, _, _)
-        G.E_MANAGER:add_event(Event({
+        Jane.q(function()
-            trigger = "after",
+            play_sound("tarot1")
-            delay = 0.4,
+            card:juice_up(0.3, 0.5)
-            func = function()
+        end, 0.4)
-                play_sound("tarot1")
-                card:juice_up(0.3, 0.5)
-                return true
-            end,
-        }))
 
         randomize(G.hand.cards)
         delay(0.5)
@@ -241,6 +209,8 @@ SMODS.Consumable {
     end,
 }
 
+local shadows_limit = 25
+
 SMODS.Consumable {
     key = "shadows",
     set = "Spectral",
@@ -256,12 +226,12 @@ SMODS.Consumable {
     config = {extra = {shadows = 2}},
     pos = {x = 3, y = 4},
     cost = 4,
-    loc_vars = function(_, _, center)
+    loc_vars = function(_, _, card)
-        return {vars = {((center.ability or {}).extra or {}).shadows or 2}}
+        return {vars = {math.min(((card.ability or {}).extra or {}).shadows or 2, shadows_limit)}}
     end,
     can_use = Jane.can_use,
     use = function(_, card, _, _)
-        for _ = 1, card.ability.extra.shadows do
+        for _ = 1, math.min(card.ability.extra.shadows, shadows_limit) do
             local joker = create_card("Joker", G.jokers, nil, nil, nil, nil, nil, "phantom")
             joker:set_edition({negative = true})
             joker.ability.eternal = false
@@ -284,7 +254,7 @@ SMODS.Consumable {
         end
     end,
     bulk_use = function(_, card, _, _, number)
-        for _ = 1, card.ability.extra.shadows * number do
+        for _ = 1, math.min(card.ability.extra.shadows, 25) * number do
             local joker = create_card("Joker", G.jokers, nil, nil, nil, nil, nil, "phantom")
             joker.no_forced_edition = true
             joker:set_edition({negative = true})
@@ -303,8 +273,9 @@ SMODS.Consumable {
             G.jokers.cards[i].extra_cost = 0
             G.jokers.cards[i].cost = 0
             G.jokers.cards[i].sell_cost = 0
-            G.jokers.cards[i].sell_cost_label = G.jokers.cards[i].facing == "back" and "?" or G.jokers.cards[i]
+
-                .sell_cost
+            G.jokers.cards[i].sell_cost_label = G.jokers.cards[i].facing == "back" and "?" or
+                G.jokers.cards[i].sell_cost
         end
     end,
 }
@@ -328,22 +299,9 @@ SMODS.Consumable {
             for _, v in pairs(G.playing_cards) do
                 v:start_dissolve()
             end
-
-            return true
         end)
 
-        local function realdelay(time, queue)
+        delay(2)
-            G.E_MANAGER:add_event(Event({
+        create_full_deck()
-                trigger = "after",
-                timer = "REAL",
-                delay = time or 1,
-                func = function()
-                    return true
-                end,
-            }), queue)
-        end
-
-        realdelay(1)
-        createfulldeck()
     end,
 }

src/tarot.lua

@@ -1,29 +1,40 @@
+local function j()
+    return G.GAME.used_vouchers.v_jane_jolly_voucher and "j_jolly" or "j_joker"
+end
+
+local required = 2
+
+local function get_uses()
+    G.GAME.joker_in_a_tarot = G.GAME.joker_in_a_tarot or 0
+    return G.GAME.joker_in_a_tarot
+end
+
 local blurbs = {
+    "M!",
     "Hey! Pick me!",
-    "You wouldn't say no to a free negative me, would you?",
+    "Hee-hee, hoo-hoo!",
-    "Sometimes, an extra four mult goes a long way!",
+    "Looks like the joke is on you!",
+    "Ouch, I think the joke is on me!",
     "I won't take up space, I promise!",
     "Don't ask how I ended up in a tarot!",
-    "Hee-hee, hoo-hoo!",
-    "Who knew even fortunes could be a circus act?",
-    "Looks like the joke is on the crystal globe!",
-    "It's a little cramped in this tarot...!",
-    "Ouch, I think the joke is on me!",
-    "Looks like the joke is on you!",
-    "I'm not just a clown; I'm the whole circus!",
-    "Seems a little suspicious for a jolly old fella like me to be in this card...",
-    "I can't help if I'm still in this silly old card, break me out!",
-    "Let me tell you, you'd love the show going on in this tarot!",
-    "I'd give you more tickets to JimCon, but I'm fresh out.",
-    "I've heard of a round buffoon that lives in a pretty funky town...",
-    "I can't give four mult if I'm still in this card!",
-    "I'm rooting for you! Even if it means I'll never get out of this card...",
-    "Who knew I'd have access to a great show? That show being you!",
     "The stakes are only gonna rise here!",
-    "Juggling is one of my favourite passtimes!",
     "I wonder what's the deal with pairs?",
+    "It's a little cramped in this tarot...!",
+    "Juggling is one of my favourite passtimes!",
+    "I'm not just a clown; I'm the whole circus!",
+    "Looks like the joke is on the crystal globe!",
+    "Who knew even fortunes could be a circus act?",
+    "Sometimes, an extra four mult goes a long way!",
+    "I can't give four mult if I'm still in this card!",
+    "You wouldn't say no to a free negative me, would you?",
+    "I'd give you more tickets to JimCon, but I'm fresh out.",
+    "Let me tell you, you'd love the show going on in this tarot!",
+    "Who knew I'd have access to a great show? That show being you!",
+    "I can't help if I'm still in this silly old card, break me out!",
+    "I've heard of a round buffoon that lives in a pretty funky town...",
     "You don't need to understand math to enjoy watching the digits climb!",
-    "M!",
+    "I'm rooting for you! Even if it means I'll never get out of this card...",
+    "Seems a little suspicious for a jolly old fella like me to be in this card...",
 }
 
 SMODS.Consumable {
@@ -31,22 +42,41 @@ SMODS.Consumable {
     atlas = "janeacc",
     set = "Tarot",
     loc_txt = {
-        name = "Joker-in-a-Tarot",
+        name = "#1#-in-a-Tarot",
         text = {
-            "Create a {C:dark_edition}Negative {C:attention}default Joker",
+            "Create a {C:dark_edition}Negative {C:attention}#2#",
-            "{C:inactive,E:1}#1#{}",
+            "after {C:attention}#3# {}uses {C:inactive}(#4# left)",
+            "{C:inactive,E:1}#5#{}",
         },
     },
     loc_vars = function(_, info_queue, card)
-        info_queue[#info_queue + 1] = G.P_CENTERS.j_joker
+        info_queue[#info_queue + 1] = G.P_CENTERS[j()]
-        card.blurb = card.blurb or pseudorandom_element(blurbs, pseudoseed("jokerinatarotblurbs"))
+        local is_jolly = G.GAME.used_vouchers.v_jane_jolly_voucher
-        return {vars = {card.blurb}}
+
+        card.blurb = not card.fake_card and
+            (card.blurb or pseudorandom_element(blurbs, pseudoseed("jokerinatarotblurbs"))) or ""
+
+        if is_jolly then
+            card.blurb = card.blurb:gsub("four", "eight")
+        end
+
+        local desc = is_jolly and "Jolly Joker" or "default Joker"
+        local name = is_jolly and "Jolly" or "Joker"
+        return {vars = {name, desc, required, required - get_uses(), card.blurb}}
     end,
     pos = {x = 0, y = 1},
     cost = 4,
     can_use = Jane.can_use,
     use = function(_, _, _, _)
-        local card = create_card("Joker", G.jokers, nil, nil, nil, nil, "j_joker", "jokerfromatarot")
+        local uses = get_uses() + 1
+
+        if uses < required then
+            G.GAME.joker_in_a_tarot = uses
+            return
+        end
+
+        G.GAME.joker_in_a_tarot = 0
+        local card = create_card("Joker", G.jokers, nil, nil, nil, nil, j(), "jokerfromatarot")
         card:set_edition({negative = true}, true)
         card.cost = 1
         card.base_cost = 1
@@ -62,3 +92,10 @@ SMODS.Consumable {
         end
     end,
 }
+
+if Cryptid then
+    Cryptid.aliases["joker in a tarot"] = "c_jane_jokerinatarot"
+    Cryptid.aliases["joker-in-a-tarot"] = "c_jane_jokerinatarot"
+    Cryptid.aliases["jolly in a tarot"] = "c_jane_jokerinatarot"
+    Cryptid.aliases["jolly-in-a-tarot"] = "c_jane_jokerinatarot"
+end

src/token.lua

@@ -20,6 +20,26 @@ SMODS.ConsumableType {
     secondary_colour = G.C.VOUCHER,
 }
 
+local function on_token_use(id)
+    local t = Tag(id)
+
+    if id == "tag_orbital" then
+        local hands = {}
+
+        for k, v in pairs(G.GAME.hands) do
+            if v.visible then
+                hands[#hands + 1] = k
+            end
+        end
+
+        t.ability.orbital_hand = pseudorandom_element(hands, pseudoseed("jane_token_orbital"))
+    end
+
+    add_tag(t)
+end
+
+local vowels = {A = true, E = true, I = true, O = true, U = true}
+
 for _, v in pairs({
     {"tag_standard",           "Standard",      0, 0, 3},
     {"tag_charm",              "Charm",         1, 0, 5},
@@ -27,57 +47,48 @@ for _, v in pairs({
     {"tag_ethereal",           "Ethereal",      3, 0, 5},
     {"tag_buffoon",            "Buffoon",       4, 0, 8},
     {"tag_cry_console",        "Console",       5, 0, 7},
-
     {"tag_cry_loss",           "Loss",          0, 1, 12},
     {"tag_cry_bundle",         "Bundle",        1, 1, 10},
     {"tag_uncommon",           "Uncommon",      2, 1, 3},
     {"tag_rare",               "Rare",          3, 1, 5},
     {"tag_cry_epic",           "Epic",          4, 1, 8},
     {"tag_cry_gourmond",       "Gourmond",      5, 1, 4},
-
     {"tag_double",             "Double",        0, 2, 6},
     {"tag_cry_triple",         "Triple",        1, 2, 8},
     {"tag_cry_quadruple",      "Quadruple",     2, 2, 10},
     {"tag_cry_quintuple",      "Quintuple",     3, 2, 13},
     {"tag_skip",               "Speed",         4, 2, 7},
     {"tag_economy",            "Economy",       5, 2, 10},
-
     {"tag_investment",         "Investment",    0, 3, 8},
     {"tag_foil",               "Foil",          1, 3, 3},
     {"tag_holo",               "Holographic",   2, 3, 4},
     {"tag_polychrome",         "Polychrome",    3, 3, 5},
     {"tag_negative",           "Negative",      4, 3, 10},
-
     {"tag_d_six",              "Dice",          0, 4, 2},
-    -- {"tag_orbital",            "Orbital",       1, 4, 6},
+    {"tag_orbital",            "Orbital",       1, 4, 6},
     {"tag_top_up",             "Top-up",        2, 4, 2},
     {"tag_cry_bettertop_up",   "Top-up+",       3, 4, 3},
     {"tag_coupon",             "Coupon",        4, 4, 10},
     {"tag_cry_memory",         "Memory",        5, 4, 8},
-
     {"tag_garbage",            "Garbage",       0, 5, 6},
     {"tag_handy",              "Handy",         1, 5, 8},
     {"tag_juggle",             "Juggle",        2, 5, 2},
     {"tag_cry_schematic",      "Schematic",     3, 5, 10},
     {"tag_voucher",            "Voucher",       4, 5, 5},
     {"tag_cry_better_voucher", "Voucher+",      5, 5, 7},
-
     {"tag_cry_gambler",        "Gamble",        0, 6, 10},
     {"tag_cry_cat",            "Cat",           1, 6, 1},
     {"tag_cry_mosaic",         "Mosaic",        2, 6, 6},
-    {"tag_cry_fragile",        "Fragile",       3, 6, 7},
+    {"tag_cry_glass",          "Fragile",       3, 6, 7},
     {"tag_cry_astral",         "Astral",        4, 6, 8},
     {"tag_cry_m",              "M",             5, 6, 8},
-
     {"tag_cry_blur",           "Blurred",       0, 7, 11},
     {"tag_cry_oversat",        "Oversaturated", 1, 7, 12},
     {"tag_cry_glitched",       "Glitched",      2, 7, 13},
     {"tag_cry_gold",           "Golden",        3, 7, 9},
     {"tag_cry_booster",        "Booster",       4, 7, 4},
     {"tag_cry_scope",          "Scope",         5, 7, 3},
-
     {"tag_cry_banana",         "Banana",        0, 8, 4},
-
 }) do
     if Cryptid or v[1]:sub(1, 7) ~= "tag_cry" then
         SMODS.Consumable {
@@ -86,11 +97,11 @@ for _, v in pairs({
             atlas = "janetokens",
             loc_txt = {
                 name = v[2] .. " Token",
-                text = {"Use to create a", "{C:attention}" .. v[2] .. " Tag"},
+                text = {"Creates a" .. (vowels[v[2]:sub(1, 1)] and "n" or "") .. " {C:attention}" .. v[2] .. " Tag"},
             },
             loc_vars = function(_, info_queue, _)
-                info_queue[#info_queue + 1] = G.P_TAGS[v[1]]
+                info_queue[#info_queue + 1] = v[1] ~= "tag_cry_cat" and G.P_TAGS[v[1]] or nil
-                return {vars = {v[2]}}
+                return {vars = {}}
             end,
             pos = {x = v[3], y = v[4]},
             cost = v[5],
@@ -102,13 +113,13 @@ for _, v in pairs({
             end,
             use = function(_, _, _, _)
                 play_sound("jane_e_gilded", 1.25, 0.4)
-                add_tag(Tag(v[1]))
+                on_token_use(v[1])
             end,
             bulk_use = function(_, _, _, _, number)
                 play_sound("jane_e_gilded", 1.25, 0.4)
 
                 for _ = 1, number do
-                    add_tag(Tag(v[1]))
+                    on_token_use(v[1])
                 end
             end,
         }

src/voucher.lua

@@ -1,3 +1,10 @@
+SMODS.Atlas {
+    key = "janejollyvoucher",
+    px = 71,
+    py = 95,
+    path = Jane.config.texture_pack .. "/v_jane_jolly_voucher.png",
+}
+
 SMODS.Atlas {
     key = "janetokenvoucher",
     px = 71,
@@ -5,6 +12,22 @@ SMODS.Atlas {
     path = Jane.config.texture_pack .. "/v_jane_token_voucher.png",
 }
 
+SMODS.Voucher {
+    key = "jolly_voucher",
+    atlas = "janejollyvoucher",
+    loc_txt = {
+        name = "Jolly Voucher",
+        text = {"{C:attention,T:c_jane_jokerinatarot}Joker-in-a-Tarot {}creates", "{C:attention,T:j_jolly}Jolly Joker {}instead"},
+    },
+    pos = {x = 0, y = 0},
+    cost = 8,
+    loc_vars = function(_, info_queue, _)
+        info_queue[#info_queue + 1] = G.P_CENTERS.c_jane_jokerinatarot
+        info_queue[#info_queue + 1] = G.P_CENTERS.j_jolly
+        return {vars = {}}
+    end,
+}
+
 SMODS.Voucher {
     key = "token_voucher",
     atlas = "janetokenvoucher",