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

.editorconfig

@@ -0,0 +1,171 @@
+
+# see https://github.com/CppCXY/EmmyLuaCodeStyle
+[*.lua]
+# [basic]
+
+# optional space/tab
+indent_style = space
+# if indent_style is space, this is valid
+indent_size = 4
+# if indent_style is tab, this is valid
+tab_width = 4
+# none/single/double
+quote_style = double
+
+continuation_indent = 4
+## extend option
+# continuation_indent.before_block = 4
+# continuation_indent.in_expr = 4
+# continuation_indent.in_table = 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 = 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 = lf
+
+#  none/ comma / semicolon / only_kv_colon
+table_separator_style = none
+
+#optional keep/never/always/smart
+trailing_table_separator = smart
+
+# keep/remove/remove_table_only/remove_string_only
+call_arg_parentheses = keep
+
+detect_end_of_line = false
+
+# this will check text end with new line
+insert_final_newline = true
+
+# [space]
+space_around_table_field_list = false
+
+space_before_attribute = false
+
+space_before_function_open_parenthesis = false
+
+space_before_function_call_open_parenthesis = false
+
+space_before_closure_open_parenthesis = false
+
+# optional always/only_string/only_table/none
+# or true/false
+space_before_function_call_single_arg = always
+## extend option
+## always/keep/none
+# space_before_function_call_single_arg.table = always
+## always/keep/none
+# space_before_function_call_single_arg.string = always
+
+space_before_open_square_bracket = false
+
+space_inside_function_call_parentheses = false
+
+space_inside_function_param_list_parentheses = false
+
+space_inside_square_brackets = false
+
+# like t[#t+1] = 1
+space_around_table_append_operator = false
+
+ignore_spaces_inside_function_call = false
+
+# detail number or 'keep'
+space_before_inline_comment = 1
+
+# convert '---' to '--- ' or '--' to '-- '
+space_after_comment_dash = false
+
+# [operator space]
+space_around_math_operator = true
+# space_around_math_operator.exponent = false
+
+space_after_comma = true
+
+space_after_comma_in_for_statement = true
+
+# true/false or none/always/no_space_asym
+space_around_concat_operator = true
+
+space_around_logical_operator = true
+
+# true/false or none/always/no_space_asym
+space_around_assign_operator = true
+
+# [align]
+
+align_call_args = false
+
+align_function_params = true
+
+# true/false or always
+align_continuous_assign_statement = true
+
+align_continuous_rect_table_field = true
+
+align_continuous_line_space = 2
+
+align_if_branch = false
+
+# option none / always / contain_curly/
+align_array_table = true
+
+align_continuous_similar_call_args = false
+
+align_continuous_inline_comment = true
+# option none / always / only_call_stmt
+align_chain_expr = none
+
+# [indent]
+
+never_indent_before_if_condition = false
+
+never_indent_comment_on_if_branch = false
+
+keep_indents_on_empty_lines = false
+
+allow_non_indented_comments = false
+# [line space]
+
+# The following configuration supports four expressions
+# keep  
+# fixed(n)   
+# min(n)
+# max(n)
+# for eg. min(2)
+
+line_space_after_if_statement = fixed(2)
+
+line_space_after_do_statement = fixed(2)
+
+line_space_after_while_statement = fixed(2)
+
+line_space_after_repeat_statement = fixed(2)
+
+line_space_after_for_statement = fixed(2)
+
+line_space_after_local_or_assign_statement = max(2)
+
+line_space_after_function_statement = fixed(2)
+
+line_space_after_expression_statement = max(2)
+
+line_space_after_comment = fixed(1)
+
+line_space_around_block = fixed(1)
+# [line break]
+break_all_list_when_line_exceed = false
+
+auto_collapse_lines = false
+
+break_before_braces = false
+
+# [preference]
+ignore_space_after_colon = false
+
+remove_call_expression_list_finish_comma = true
+# keep / always / same_line / replace_with_newline / never
+end_statement_with_semicolon = replace_with_newline

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

@@ -1,7 +1,15 @@
 [manifest]
 version = "1.0.0"
 dump_lua = true
-priority = 2147483647
+priority = 114
+
+[[patches]]
+[patches.pattern]
+target = "card.lua"
+pattern = "if v ~= chosen_joker then"
+position = "at"
+payload = "if v ~= chosen_joker and not next(SMODS.find_card('j_jane_saint')) then"
+match_indent = true
 
 [[patches]]
 [patches.pattern]
@@ -20,7 +28,6 @@ pattern = "if v.name == 'Black Hole' or v.name == 'The Soul' or v.hidden then"
 position = "at"
 payload = "if Jane.hidden(v) then"
 match_indent = true
-overwrite = false
 
 [[patches]]
 [patches.pattern]
@@ -35,29 +42,113 @@ match_indent = true
 target = "functions/misc_functions.lua"
 pattern = "local AC = G.SETTINGS.ambient_control"
 position = "before"
-payload = '''if Jane and G.ARGS.score_intensity.required_score ~= 0 then
+payload = '''if Jane and (type(G.ARGS.score_intensity.required_score) == "table" and G.ARGS.score_intensity.required_score:to_number() or G.ARGS.score_intensity.required_score) ~= 0 then
-	Jane.sinister = (G.ARGS.score_intensity.earned_score / (to_big(10) ^ to_big(G.ARGS.score_intensity.required_score))):to_number() > 1
+    local break_infinity = ((Talisman or {}).config_file or {}).break_infinity
+    local big = (break_infinity == "" or break_infinity == nil) and function (x) return x end or to_big
+    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
 
 [[patches]]
 [patches.pattern]
 target = "functions/state_events.lua"
-pattern = "scoring_hand = final_scoring_hand"
+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
+    if Cryptid then
+        for _, v in ipairs(G.hand.cards) do
+            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}, 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
+
+[[patches]]
+[patches.pattern]
+target = "functions/state_events.lua"
+pattern = "SMODS.calculate_main_scoring({cardarea = v, full_hand = G.play.cards, scoring_hand = scoring_hand, scoring_name = text, poker_hands = poker_hands}, v == G.play and scoring_hand or nil)"
+position = "after"
+payload = "end"
+match_indent = true
+
+[[patches]]
+[patches.pattern]
+target = "functions/state_events.lua"
+pattern = "-- context.final_scoring_step calculations"
+position = "before"
+payload = '''if 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 _, area in ipairs(SMODS.get_card_areas('jokers')) do
+        for _, _card in ipairs(area.cards) do
+            local eval = eval_card(_card, {
+                cardarea = G.jokers,
+                full_hand = G.hand.cards,
+                scoring_hand = G.hand.cards,
+                scoring_name = text,
+                poker_hands = poker_hands,
+                edition = true,
+                pre_joker = true
+            })
+        end
+    end
+end'''
+match_indent = true
+
+[[patches]]
+[patches.pattern]
+target = "functions/state_events.lua"
+pattern = "SMODS.calculate_context({full_hand = G.play.cards, scoring_hand = scoring_hand, scoring_name = text, poker_hands = poker_hands, final_scoring_step = true})"
 position = "after"
 payload = '''if 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
+    SMODS.calculate_context({full_hand = G.hand.cards, scoring_hand = G.hand.cards, scoring_name = text, poker_hands = poker_hands, final_scoring_step = true})
-		if not v:gc().unhighlightable then
+end'''
-			table.insert(scoring_hand, v)
+match_indent = true
-		end
+
-	end
+[[patches]]
+[patches.pattern]
+target = "functions/state_events.lua"
+pattern = "-- context.remove_playing_cards calculations"
+position = "before"
+payload = '''if 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
+    SMODS.calculate_destroying_cards({ full_hand = G.hand.cards, scoring_hand = G.hand.cards, scoring_name = text, poker_hands = poker_hands, cardarea = G.hand }, cards_destroyed, G.hand)
 end'''
 match_indent = true
 
 [[patches]]
 [patches.regex]
 target = "functions/state_events.lua"
-pattern = '''hand_chips\*mult'''
+pattern = '''hand_chips\*mult\)'''
 position = "at"
-payload = "Jane.get_chipmult_sum(hand_chips, mult)"
+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

@@ -1,16 +1,21 @@
 {
     "id": "jane",
     "name": "Almighty",
-    "author": ["jenwalter666", "Emik"],
+    "author": [
-    "description": "Fork of Jen's almanac that focuses on only including the absolute best parts of the mod, and removing everything else.",
+        "jenwalter666",
+        "Emik"
+    ],
+    "description": "Fork of Jen's almanac that rebalances the mod by heavily toning down on the power creep and cutting out anything deemed not essential. Made out of genuine love for the original mod.",
     "prefix": "jane",
     "main_file": "src/main.lua",
     "badge_colour": "3c3cff",
-	"priority": 999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999,
+    "priority": 114,
     "dependencies": [
         "Steamodded (>=1.0.0~ALPHA-1304a)",
         "Bakery (>=0.1.26~*)"
     ],
-    "conflicts": ["Jen"],
+    "conflicts": [
-    "version": "0.1.0"
+        "Jen"
+    ],
+    "version": "1.5.19"
 }

refs/CardSleeves

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

src/blind.lua

@@ -1,16 +1,16 @@
 SMODS.Atlas {
     px = 34,
-	py = 34,
+    py = 34,
     frames = 21,
     key = "janeblinds",
-	atlas_table = "ANIMATION_ATLAS",
+    atlas_table = "ANIMATION_ATLAS",
-	path = Jane.config.texture_pack .. "/bl_jane_blinds.png"
+    path = Jane.config.texture_pack .. "/bl_jane_blinds.png",
 }
 
 local final_operations = {
-	[1] = {"+", "UI_CHIPS"},
+    [1] = {"+", "UI_CHIPS"},
-	[2] = {"X", "UI_MULT"},
+    [2] = {"X", "UI_MULT"},
-	[3] = {"^", G.C.jane_RGB},
+    [3] = {"^", G.C.jane_RGB},
 }
 
 local function offset_operator(by)
@@ -22,9 +22,9 @@ local function offset_operator(by)
 
     local previous = Jane.get_operator()
     set(by + previous)
-	by = Jane.get_operator()
+    by = Jane.get_operator()
-	local txt = final_operations[by][1] ---@diagnostic disable-next-line: cast-local-type
+    local txt = final_operations[by][1] ---@diagnostic disable-next-line: cast-local-type
-	local col = type(final_operations[by][2]) == "table" and final_operations[by][2] or G.C[final_operations[by][2]]
+    local col = type(final_operations[by][2]) == "table" and final_operations[by][2] or G.C[final_operations[by][2]]
 
     Jane.q(function()
         local changed_text = false
@@ -35,7 +35,7 @@ local function offset_operator(by)
                     if type(inner) == "table" and
                         type(inner.config) == "table" and
                         (inner.config.text == final_operations[previous][1] or
-                        inner.config.text == final_operations[2][1]) and
+                            inner.config.text == final_operations[2][1]) and
                         inner.config.text_drawable then
                         if inner.config.text ~= txt then
                             changed_text = true
@@ -53,15 +53,17 @@ local function offset_operator(by)
         if changed_text then
             play_sound("button", 1.1, 0.65)
         end
-
-	    return true
     end)
 end
 
-SMODS.Blind	{
+local function to_number(x)
+    return type(x) == "table" and x:to_number() or x
+end
+
+SMODS.Blind {
     loc_txt = {
         name = "The Descending",
-        text = {"Decrease Chip-Mult", "operator by 1 level"}
+        text = {"Decrease Chip-Mult", "operator by 1 level"},
     },
     key = "descending",
     config = {},
@@ -70,14 +72,15 @@ SMODS.Blind	{
     atlas = "janeblinds",
     pos = {x = 0, y = 0},
     vars = {},
-    dollars = 15,
+    dollars = 6,
-    mult = 0.5,
     defeat = function(_)
-        if not G.GAME.blind.disabled then
+        if not Cryptid then
+            offset_operator(2 - Jane.get_operator())
+        elseif not G.GAME.blind.disabled then
             offset_operator(1)
         end
     end,
-    disable = function(self)
+    disable = function(_)
         offset_operator(1)
     end,
     drawn_to_hand = function(_)
@@ -86,15 +89,19 @@ SMODS.Blind	{
     press_play = function(_)
         offset_operator(0)
     end,
-    set_blind = function(_)
+    set_blind = function(self)
+        if to_number(self.mult) == 0 then
+            self.chips = math.floor(8 * math.sqrt(get_blind_amount(G.GAME.round_resets.ante)))
+        end
+
         offset_operator(-1)
     end,
 }
 
-SMODS.Blind	{
+SMODS.Blind {
     loc_txt = {
         name = "The Insignia",
-        text = {"Hand must contain", "only one suit"}
+        text = {"Hand must contain", "only one suit"},
     },
     key = "insignia",
     config = {},
@@ -103,50 +110,63 @@ SMODS.Blind	{
     atlas = "janeblinds",
     pos = {x = 0, y = 9},
     vars = {},
-    dollars = 7,
+    dollars = 5,
     mult = 2,
-	debuff_hand = function(_, cards, _, _, _)
+    debuff_hand = function(_, cards, _, _, _)
-		local numsuits = 0
+        local numsuits = 0
-		local checked_suits = {}
+        local checked_suits = {}
 
-		for _, card in ipairs(cards) do
+        for _, card in ipairs(cards) do
-			if not card:nosuit() and not checked_suits[card.base.suit] then
+            if not card:nosuit() and not checked_suits[card.base.suit] then
-				numsuits = numsuits + 1
+                numsuits = numsuits + 1
-				checked_suits[card.base.suit] = true
+                checked_suits[card.base.suit] = true
 
-				if numsuits > 1 then
+                if numsuits > 1 then
                     return true
                 end
-			end
+            end
-		end
+        end
-	end
+    end,
 }
 
-SMODS.Blind	{
+SMODS.Blind {
     loc_txt = {
         name = "The Wee",
-        text = {"Only 2s can be played"}
+        text = {"Only 2s can be played"},
     },
     key = "wee",
     config = {},
-    boss = {min = 1, max = 10, no_orb = true, hardcore = true},
+    boss = {min = 2, max = 10, no_orb = true, hardcore = true},
     boss_colour = HEX("7F3F3F"),
     atlas = "janeblinds",
     pos = {x = 0, y = 3},
     vars = {},
     dollars = 2,
-    mult = 22 / 300,
+    disable = function(self)
-	debuff_hand = function(_, cards, _, _, _)
+        self.disabled = true
-		for _, v in ipairs(cards) do
+    end,
-			if v:norank() or v:get_id() ~= 2 then
+    debuff_hand = function(self, cards, _, _, _)
-				return true
+        if self.disabled then
-			end
+            return false
-		end
+        end
-	end,
+
-	get_loc_debuff_text = function(_)
+        for _, v in ipairs(cards) do
-		return "Hand must contain only 2s"
+            if (v:norank() or v:get_id() ~= 2) and (v.ability or {}).aikoyori_letters_stickers ~= "2" then
-	end,
+                return true
-	recalc_debuff = function(_, card, _)
+            end
-		return card:norank() or card:get_id() ~= 2
+        end
-	end,
+    end,
+    get_loc_debuff_text = function(_)
+        return "Hand must contain only 2s"
+    end,
+    recalc_debuff = function(self, card, _)
+        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
+            self.chips = 22
+        end
+    end,
 }

src/booster.lua

@@ -1,37 +1,51 @@
 SMODS.Atlas {
-	px = 71,
+    px = 71,
-	py = 95,
+    py = 95,
-	key = "janebooster",
+    key = "janebooster",
-	path = Jane.config.texture_pack .. "/p_jane_boosters.png"
+    path = Jane.config.texture_pack .. "/p_jane_boosters.png",
 }
 
 for i = 1, 2 do
-	SMODS.Booster{
+    SMODS.Booster {
-		key = "ministandard" .. i,
+        key = "ministandard" .. i,
-		loc_txt = {
+        loc_txt = {
-			name = "Mini Standard Pack",
+            name = "Mini Standard Pack",
-			text = {
+            text = {
-				"Choose {C:attention}#1#{} of up to",
+                "Choose {C:attention}#1#{} of up to",
-				"{C:attention}#2# playing cards{} to",
+                "{C:attention}#2# playing cards{} to",
-				"add to your deck",
+                "add to your deck",
-			}
+            },
-		},
+        },
-		atlas = "janebooster",
+        atlas = "janebooster",
-		pos = {x = 6, y = i - 1},
+        pos = {x = 6, y = i - 1},
-		weight = 0.4,
+        weight = 0.4,
-		cost = 2,
+        cost = 2,
-		config = {extra = 2, choose = 1},
+        config = {extra = 2, choose = 1},
-		loc_vars = function(_, _, card)
+        loc_vars = function(_, _, card)
-			return {vars = {card.ability.choose, card.ability.extra}}
+            return {vars = {card.ability.choose, card.ability.extra}}
-		end,
+        end,
-        ease_background_colour = function(_)
+        create_card = function(_, _, _)
-			ease_background_colour_blind(G.STATES.STANDARD_PACK)
+            local edition = poll_edition("standard_edition" .. G.GAME.round_resets.ante, 2, true)
-		end,
+            local seal = SMODS.poll_seal({mod = 10})
+
+            return {
+                set = (pseudorandom(pseudoseed("stdset" .. G.GAME.round_resets.ante)) > 0.6) and "Enhanced" or "Base",
+                edition = edition,
+                seal = seal,
+                area = G.pack_cards,
+                skip_materialize = true,
+                soulable = true,
+                key_append = "sta",
+            }
+        end,
         create_UIBox = function(_)
-			return create_UIBox_standard_pack()
+            return create_UIBox_standard_pack()
-		end,
+        end,
+        ease_background_colour = function(_)
+            ease_background_colour_blind(G.STATES.STANDARD_PACK)
+        end,
         particles = function(_)
-            G.booster_pack_sparkles = Particles(1, 1, 0,0, {
+            G.booster_pack_sparkles = Particles(1, 1, 0, 0, {
                 timer = 0.015,
                 scale = 0.3,
                 initialize = true,
@@ -40,57 +54,62 @@ for i = 1, 2 do
                 padding = -1,
                 attach = G.ROOM_ATTACH,
                 colours = {G.C.BLACK, G.C.RED},
-                fill = true
+                fill = true,
             })
 
             G.booster_pack_sparkles.fade_alpha = 1
             G.booster_pack_sparkles:fade(1, 0)
         end,
-        create_card = function(_, _, _)
+    }
-            local edition = poll_edition("standard_edition"..G.GAME.round_resets.ante, 2, true)
-            local seal = SMODS.poll_seal({mod = 10})
-
-            return {
-				set = (pseudorandom(pseudoseed("stdset"..G.GAME.round_resets.ante)) > 0.6) and "Enhanced" or "Base",
-				edition = edition,
-				seal = seal,
-				area = G.pack_cards,
-				skip_materialize = true,
-				soulable = true,
-				key_append = "sta"
-			}
-        end,
-	}
 end
 
 for i = 1, 2 do
-	SMODS.Booster{
+    SMODS.Booster {
-		key = "miniarcana" .. i,
+        key = "miniarcana" .. i,
-		loc_txt = {
+        loc_txt = {
-			name = "Mini Arcana Pack",
+            name = "Mini Arcana Pack",
-			text = {
+            text = {
-				"Choose {C:attention}#1#{} of up to",
+                "Choose {C:attention}#1#{} of up to",
-				"{C:attention}#2# {C:tarot}Tarot{} cards to",
+                "{C:attention}#2# {C:tarot}Tarot{} cards to",
-				"be used immediately",
+                "be used immediately",
-			}
+            },
-		},
+        },
-		atlas = "janebooster",
+        atlas = "janebooster",
-		pos = {x = 3 + i, y = 1},
+        pos = {x = 3 + i, y = 1},
-		weight = 0.4,
+        weight = 0.4,
-		cost = 2,
+        cost = 2,
-		config = {extra = 2, choose = 1},
+        config = {extra = 2, choose = 1},
-		draw_hand = true,
+        draw_hand = true,
-		loc_vars = function(_, _, card)
+        loc_vars = function(_, _, card)
-			return {vars = {card.ability.choose, card.ability.extra}}
+            return {vars = {card.ability.choose, card.ability.extra}}
-		end,
+        end,
-        ease_background_colour = function(_)
+        create_card = function(_, _, _)
-			ease_background_colour_blind(G.STATES.TAROT_PACK)
+            if G.GAME.used_vouchers.v_omen_globe and pseudorandom("omen_globe") > 0.8 then
-		end,
+                return {
+                    set = "Spectral",
+                    soulable = true,
+                    key_append = "ar2",
+                    area = G.pack_cards,
+                    skip_materialize = true,
+                }
+            end
+
+            return {
+                set = "Tarot",
+                soulable = true,
+                key_append = "ar1",
+                area = G.pack_cards,
+                skip_materialize = true,
+            }
+        end,
         create_UIBox = function(_)
-			return create_UIBox_arcana_pack()
+            return create_UIBox_arcana_pack()
-		end,
+        end,
+        ease_background_colour = function(_)
+            ease_background_colour_blind(G.STATES.TAROT_PACK)
+        end,
         particles = function(_)
-            G.booster_pack_sparkles = Particles(1, 1, 0,0, {
+            G.booster_pack_sparkles = Particles(1, 1, 0, 0, {
                 timer = 0.015,
                 scale = 0.2,
                 initialize = true,
@@ -99,147 +118,146 @@ for i = 1, 2 do
                 padding = -1,
                 attach = G.ROOM_ATTACH,
                 colours = {G.C.WHITE, lighten(G.C.PURPLE, 0.4), lighten(G.C.PURPLE, 0.2), lighten(G.C.GOLD, 0.2)},
-                fill = true
+                fill = true,
             })
 
             G.booster_pack_sparkles.fade_alpha = 1
             G.booster_pack_sparkles:fade(1, 0)
         end,
-        create_card = function(_, _, _)
+    }
-            if G.GAME.used_vouchers.v_omen_globe and pseudorandom("omen_globe") > 0.8 then
+end
+
+for i = 1, 2 do
+    SMODS.Booster {
+        key = "minicelestial" .. i,
+        atlas = "janebooster",
+        loc_txt = {
+            name = "Mini Celestial Pack",
+            text = {
+                "Choose {C:attention}#1#{} of up to",
+                "{C:attention}#2# {C:planet}Planet{} cards to",
+                "be used immediately",
+            },
+        },
+        config = {extra = 2, choose = 1},
+        pos = {x = 3 + i, y = 0},
+        cost = 2,
+        weight = 0.4,
+        loc_vars = function(_, _, card)
+            return {vars = {card.ability.choose, card.ability.extra}}
+        end,
+        create_card = function(_, _, index)
+            if not G.GAME.used_vouchers.v_telescope or index ~= 1 then
                 return {
-					set = "Spectral",
+                    set = "Planet",
-					soulable = true,
+                    area = G.pack_cards,
-					key_append = "ar2",
+                    skip_materialize = true,
-					area = G.pack_cards,
+                    soulable = true,
-					skip_materialize = true,
+                    key_append = "pl1",
-				}
+                }
+            end
+
+            local planet, hand, tally = nil, nil, 0
+
+            for _, v in ipairs(G.handlist) do
+                if G.GAME.hands[v].visible and G.GAME.hands[v].played > tally then
+                    hand = v
+                    tally = G.GAME.hands[v].played
+                end
+            end
+
+            if hand then
+                for _, v in pairs(G.P_CENTER_POOLS.Planet) do
+                    if v.config.hand_type == hand then
+                        planet = v.key
+                    end
+                end
             end
 
             return {
-				set = "Tarot",
+                key = planet,
-				soulable = true,
+                set = "Planet",
-				key_append = "ar1",
+                soulable = true,
-				area = G.pack_cards,
+                key_append = "pl1",
-				skip_materialize = true,
+                area = G.pack_cards,
-			}
+                skip_materialize = true,
-        end
+            }
-	}
+        end,
-end
-
-for i = 1, 2 do
-	SMODS.Booster{
-		key = "minicelestial" .. i,
-		atlas = "janebooster",
-		loc_txt = {
-			name = "Mini Celestial Pack",
-			text = {
-				"Choose {C:attention}#1#{} of up to",
-				"{C:attention}#2# {C:planet}Planet{} cards to",
-				"be used immediately",
-			}
-		},
-		config = {extra = 2, choose = 1},
-		pos = {x = 3 + i, y = 0},
-		cost = 2,
-		weight = 0.4,
-		loc_vars = function(_, _, card)
-			return {vars = {card.ability.choose, card.ability.extra}}
-		end,
-		ease_background_colour = function(_) ease_background_colour_blind(G.STATES.PLANET_PACK) end,
-		create_UIBox = function(_) return create_UIBox_celestial_pack() end,
-		particles = function(_)
-			G.booster_pack_stars = Particles(1, 1, 0,0, {
-				fill = true,
-				scale = 0.1,
-				speed = 0.1,
-				timer = 0.07,
-				padding = -4,
-				lifespan = 15,
-				initialize = true,
-				attach = G.ROOM_ATTACH,
-				colours = {G.C.WHITE, HEX("a7d6e0"), HEX("fddca0")},
-			})
-
-			G.booster_pack_meteors = Particles(1, 1, 0,0, {
-				speed = 4,
-				timer = 2,
-				fill = true,
-				scale = 0.05,
-				lifespan = 1.5,
-				attach = G.ROOM_ATTACH,
-				colours = {G.C.WHITE},
-			})
-		end,
-		create_card = function(_, _, index)
-			if not G.GAME.used_vouchers.v_telescope or index ~= 1 then
-				return {
-					set = "Planet",
-					area = G.pack_cards,
-					skip_materialize = true,
-					soulable = true,
-					key_append = "pl1"
-				}
-			end
-
-			local planet, hand, tally = nil, nil, 0
-
-			for _, v in ipairs(G.handlist) do
-				if G.GAME.hands[v].visible and G.GAME.hands[v].played > tally then
-					hand = v
-					tally = G.GAME.hands[v].played
-				end
-			end
-
-			if hand then
-				for _, v in pairs(G.P_CENTER_POOLS.Planet) do
-					if v.config.hand_type == hand then
-						planet = v.key
-					end
-				end
-			end
-
-			return {
-				key = planet,
-				set = "Planet",
-				soulable = true,
-				key_append = "pl1",
-				area = G.pack_cards,
-				skip_materialize = true,
-			}
-		end
-	}
-end
-
-for i = 1, 2 do
-	SMODS.Booster{
-		key = "minispectral" .. i,
-		atlas = "janebooster",
-		loc_txt = {
-			name = "Mini Spectral Pack",
-			text = {
-				"Choose {C:attention}#1#{} of up to",
-				"{C:attention}#2# {C:spectral}Spectral{} cards to",
-				"be used immediately",
-			}
-		},
-		config = {extra = 1, choose = 1},
-		pos = {x = 3 + i, y = 2},
-		cost = 2,
-		weight = 0.225,
-		draw_hand = true,
-		loc_vars = function(_, _, card)
-			return {vars = {card.ability.choose, card.ability.extra}}
-		end,
-        ease_background_colour = function(_)
-			ease_background_colour_blind(G.STATES.SPECTRAL_PACK)
-		end,
         create_UIBox = function(_)
-			return create_UIBox_spectral_pack()
+            return create_UIBox_celestial_pack()
-		end,
+        end,
+        ease_background_colour = function(_)
+            ease_background_colour_blind(G.STATES.PLANET_PACK)
+        end,
         particles = function(_)
-            G.booster_pack_sparkles = Particles(1, 1, 0,0, {
+            G.booster_pack_stars = Particles(1, 1, 0, 0, {
-				scale = 0.1,
+                fill = true,
+                scale = 0.1,
+                speed = 0.1,
+                timer = 0.07,
+                padding = -4,
+                lifespan = 15,
+                initialize = true,
+                attach = G.ROOM_ATTACH,
+                colours = {G.C.WHITE, HEX("a7d6e0"), HEX("fddca0")},
+            })
+
+            G.booster_pack_meteors = Particles(1, 1, 0, 0, {
+                speed = 4,
+                timer = 2,
+                fill = true,
+                scale = 0.05,
+                lifespan = 1.5,
+                attach = G.ROOM_ATTACH,
+                colours = {G.C.WHITE},
+            })
+        end,
+        set_ability = function(_, card, _, _)
+            card.ability = card.ability or {}
+            card.ability.set = "Booster"
+            card.ability.name = "Mini Celestial Pack"
+        end,
+    }
+end
+
+for i = 1, 2 do
+    SMODS.Booster {
+        key = "minispectral" .. i,
+        atlas = "janebooster",
+        loc_txt = {
+            name = "Mini Spectral Pack",
+            text = {
+                "Choose {C:attention}#1#{} of up to",
+                "{C:attention}#2# {C:spectral}Spectral{} cards to",
+                "be used immediately",
+            },
+        },
+        config = {extra = 1, choose = 1},
+        pos = {x = 3 + i, y = 2},
+        cost = 2,
+        weight = 0.225,
+        draw_hand = true,
+        loc_vars = function(_, _, card)
+            return {vars = {card.ability.choose, card.ability.extra}}
+        end,
+        create_card = function(_, _, _)
+            return {
+                soulable = true,
+                set = "Spectral",
+                key_append = "spe",
+                area = G.pack_cards,
+                skip_materialize = true,
+            }
+        end,
+        create_UIBox = function(_)
+            return create_UIBox_spectral_pack()
+        end,
+        ease_background_colour = function(_)
+            ease_background_colour_blind(G.STATES.SPECTRAL_PACK)
+        end,
+        particles = function(_)
+            G.booster_pack_sparkles = Particles(1, 1, 0, 0, {
+                scale = 0.1,
                 fill = true,
                 speed = 0.2,
                 lifespan = 3,
@@ -253,14 +271,163 @@ for i = 1, 2 do
             G.booster_pack_sparkles.fade_alpha = 1
             G.booster_pack_sparkles:fade(1, 0)
         end,
-        create_card = function(_, _, _)
+    }
-            return {
+end
-				soulable = true,
+
-				set = "Spectral",
+if Cryptid then
-				key_append = "spe",
+    SMODS.Booster {
-				area = G.pack_cards,
+        atlas = "janebooster",
-				skip_materialize = true,
+        key = "minicode",
-			}
+        loc_txt = {
-        end,
+            name = "Mini Code Pack",
-	}
+            text = {
+                "Choose {C:attention}#1#{} of up to",
+                "{C:attention}#2# {C:green}Code{} cards to",
+                "be used immediately",
+            },
+        },
+        pos = {x = 6, y = 2},
+        config = {extra = 2, choose = 1},
+        cost = 2,
+        weight = 0.24,
+        create_card = function(_, _)
+            return create_card("Code", G.pack_cards, nil, nil, true, true, nil, "cry_program_3")
+        end,
+        ease_background_colour = function(_)
+            ease_colour(G.C.DYN_UI.MAIN, G.C.SET.Code)
+            ease_background_colour({new_colour = G.C.SET.Code, special_colour = G.C.BLACK, contrast = 2})
+        end,
+        loc_vars = function(self, _, card)
+            return {
+                vars = {
+                    card and card.ability.choose or self.config.choose,
+                    card and card.ability.extra or self.config.extra,
+                },
+            }
+        end,
+        cry_digital_hallucinations = {
+            colour = HEX("14b341"),
+            loc_key = "cry_plus_code",
+            create = function()
+                local ccard = create_card("Code", G.consumeables, nil, nil, nil, nil, nil, "diha")
+                ccard:set_edition({negative = true}, true)
+                ccard:add_to_deck()
+                G.consumeables:emplace(ccard)
+            end,
+        },
+    }
+end
+
+for i = 1, 2 do
+    SMODS.Booster {
+        key = "minitoken" .. i,
+        atlas = "janebooster",
+        loc_txt = {
+            name = "Mini Token Pack",
+            text = {
+                "Choose {C:attention}#1#{} of up to",
+                "{C:attention}#2# Token {}cards to",
+                "be used immediately",
+            },
+        },
+        pos = {x = i - 1, y = 5},
+        config = {extra = 2, choose = 1},
+        cost = 2,
+        weight = 0.2,
+        loc_vars = function(_, _, card)
+            return {vars = {card.ability.choose, card.ability.extra}}
+        end,
+        create_card = function(_, _, _)
+            return create_card("jane_tokens", G.pack_cards, nil, nil, true, true, nil, "jane_tokens" .. i)
+        end,
+        create_UIBox = function(_)
+            local size = SMODS.OPENED_BOOSTER.ability.extra
+
+            G.pack_cards = CardArea(
+                G.ROOM.T.x + 9 + G.hand.T.x, G.hand.T.y,
+                math.max(1, math.min(size, 5)) * G.CARD_W * 1.1,
+                1.05 * G.CARD_H,
+                {card_limit = size, highlight_limit = 1, type = "consumeable"}
+            )
+
+            local t = {
+                n = G.UIT.ROOT,
+                config = {align = "tm", r = 0.15, colour = G.C.CLEAR, padding = 0.15},
+                nodes = {
+                    {
+                        n = G.UIT.R,
+                        config = {align = "cl", colour = G.C.CLEAR, r = 0.15, padding = 0.1, minh = 2, shadow = true},
+                        nodes = {
+                            {
+                                n = G.UIT.R,
+                                config = {align = "cm"},
+                                nodes = {
+                                    {
+                                        n = G.UIT.C,
+                                        config = {align = "cm", padding = 0.1},
+                                        nodes = {
+                                            {
+                                                n = G.UIT.C,
+                                                config = {align = "cm", r = 0.2, colour = G.C.CLEAR, shadow = true},
+                                                nodes = {
+                                                    {n = G.UIT.O, config = {object = G.pack_cards}}},
+                                            }},
+                                    }},
+                            },
+                            {n = G.UIT.R, config = {align = "cm"}, nodes = {}},
+                            {
+                                n = G.UIT.R,
+                                config = {align = "tm"},
+                                nodes = {
+                                    {n = G.UIT.C, config = {align = "tm", padding = 0.05, minw = 2.4}, nodes = {}},
+                                    {
+                                        n = G.UIT.C,
+                                        config = {align = "tm", padding = 0.05},
+                                        nodes = {
+                                            UIBox_dyn_container({
+                                                {
+                                                    n = G.UIT.C,
+                                                    config = {align = "cm", padding = 0.05, minw = 4},
+                                                    nodes = {
+                                                        {
+                                                            n = G.UIT.R,
+                                                            config = {align = "bm", padding = 0.05},
+                                                            nodes = {
+                                                                {n = G.UIT.O, config = {object = DynaText({string = {"Token Pack"}, colours = {G.C.WHITE}, shadow = true, rotate = true, bump = true, spacing = 2, scale = 0.7, maxw = 4, pop_in = 0.5})}}},
+                                                        },
+                                                        {
+                                                            n = G.UIT.R,
+                                                            config = {align = "bm", padding = 0.05},
+                                                            nodes = {
+                                                                {n = G.UIT.O, config = {object = DynaText({string = {localize("k_choose") .. " "}, colours = {G.C.WHITE}, shadow = true, rotate = true, bump = true, spacing = 2, scale = 0.5, pop_in = 0.7})}},
+                                                                {n = G.UIT.O, config = {object = DynaText({string = {{ref_table = G.GAME, ref_value = "pack_choices"}}, colours = {G.C.WHITE}, shadow = true, rotate = true, bump = true, spacing = 2, scale = 0.5, pop_in = 0.7})}}},
+                                                        }},
+                                                },
+                                            })},
+                                    },
+                                    {
+                                        n = G.UIT.C,
+                                        config = {align = "tm", padding = 0.05, minw = 2.4},
+                                        nodes = {
+                                            {n = G.UIT.R, config = {minh = 0.2}, nodes = {}},
+                                            {
+                                                n = G.UIT.R,
+                                                config = {align = "tm", padding = 0.2, minh = 1.2, minw = 1.8, r = 0.15, colour = G.C.GREY, one_press = true, button = "skip_booster", hover = true, shadow = true, func = "can_skip_booster"},
+                                                nodes = {
+                                                    {n = G.UIT.T, config = {text = localize("b_skip"), scale = 0.5, colour = G.C.WHITE, shadow = true, focus_args = {button = "y", orientation = "bm"}, func = "set_button_pip"}}},
+                                            }},
+                                    }},
+                            }},
+                    }},
+            }
+
+            return t
+        end,
+        ease_background_colour = function(_)
+            ease_background_colour {new_colour = HEX(i == 1 and "F0C197" or "FD5F55"), special_colour = HEX("000000"), contrast = 5}
+        end,
+        in_pool = function(_, _)
+            return G.GAME.used_vouchers.v_jane_token_voucher
+        end,
+    }
 end

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,24 +1,25 @@
-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 resize(card, mod, force_save)
+local function allow_moire()
-	if force_save or not card.origsize then
+    if Cryptid then
-		card.origsize = {w = card.T.w, h = card.T.h}
+        return true
-	end
+    end
 
-	card:hard_set_T(card.T.x, card.T.y, card.T.w * mod, card.T.h * mod)
+    for _, v in pairs(SMODS.find_card("j_jane_saint")) do
-	remove_all(card.children)
+        if v.ability.extra.is_attuned then
-	card.children = {}
+            return true
-	card.children.shadow = Moveable(0, 0, 0, 0)
+        end
-	card:set_sprites(card.config.center, card.base.id and card.config.card)
+    end
 
-	if card.area and
+    return false
-		((G.shop_jokers and card.area == G.shop_jokers) or
+end
-		(G.shop_booster and card.area == G.shop_booster) or
+
-		(G.shop_vouchers and card.area == G.shop_vouchers)) then
+local function get_weight(self)
-		create_shop_card_ui(card)
+    return G.GAME.edition_rate * self.weight * (allow_moire() and 1 or 0)
-	end
 end
 
 SMODS.Edition({
@@ -26,111 +27,158 @@ SMODS.Edition({
     loc_txt = {
         name = "Polygloss",
         label = "Polygloss",
-        text = {
+        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",
-			"Generates {C:money}+$#7#",
+            "{C:money}$#5# {}when scored",
-			"{C:dark_edition,s:0.7,E:2}Shader by : Oiiman"
+        } or {
-        }
+            "{C:chips}+#1#{} Chips",
+            "{C:mult}+#2#{} & {X:mult,C:white}X#3#{} Mult",
+            "{C:money}$#4# {}when scored",
+        },
     },
-    config = {chips = 1, mult = 1, x_chips = 1.1, x_mult = 1.1, e_chips = 1.01, e_mult = 1.01, p_dollars = 1},
+    config = {
-	sound = {
+        mult = 2,
-		sound = "jane_e_polygloss",
+        chips = 12,
-		per = 1.2,
+        x_mult = 1.2,
-		vol = 0.4
+        p_dollars = 1,
-	},
+        e_mult = Cryptid and 1.02 or nil,
+    },
+    sound = {sound = "jane_e_polygloss", per = 1.2, vol = 0.4},
     weight = 8,
-    extra_cost = 2,
+    extra_cost = 4,
     in_shop = true,
     shader = "polygloss",
     apply_to_float = false,
-    loc_vars = function(self)
+    loc_vars = function(self, _, _)
-        return {vars = {
+        local vars = {self.config.chips}
-			self.config.chips,
+        vars[#vars + 1] = self.config.mult
-			self.config.x_chips,
+        vars[#vars + 1] = self.config.x_mult
-			self.config.e_chips,
+        vars[#vars + 1] = self.config.e_mult
-			self.config.mult,
+        vars[#vars + 1] = self.config.p_dollars
-			self.config.x_mult,
+        return {vars = vars}
-			self.config.e_mult,
+    end,
-			self.config.p_dollars
+    calculate = function(_, card, context)
-		}}
+        if context.pre_joker then
-    end
+            return {
+                mult = card.edition.mult,
+                chips = card.edition.chips,
+            }
+        elseif context.post_joker then
+            return {
+                e_mult = card.edition.e_mult,
+                x_mult = card.edition.x_mult,
+                p_dollars = card.edition.p_dollars,
+            }
+        elseif context.main_scoring and context.cardarea == G.play then
+            return {
+                mult = card.edition.mult,
+                chips = card.edition.chips,
+                e_mult = card.edition.e_mult,
+                x_mult = card.edition.x_mult,
+                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({
-	key = "jumbo",
+    key = "jumbo",
-	loc_txt = {
+    loc_txt = {
-		name = "Jumbo",
+        name = "Jumbo",
-		label = "Jumbo",
+        label = "Jumbo",
-		text = {
+        text = {
-			"All card values are",
+            "All card values are",
-			"{C:attention}multiplied{} by {C:attention}up to " .. jumbo_modifier,
+            "{C:attention}multiplied{} by {C:attention}up to " .. jumbo_modifier,
-			"{C:inactive}(If possible)",
+            "{C:inactive}(If possible)",
-			"{C:inactive,E:1,s:0.7}Whoa, it's huge!!{}"
+            "{C:inactive,E:1,s:0.7}Whoa, it's huge!!{}",
-		}
+        },
-	},
+    },
-	on_apply = function(card)
+    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()
-				resize(card, Jane.config.wee_sizemod)
-				return true
-			end
-		}))
 
-		local obj = card:gc()
+        local obj = card:gc()
 
-		if obj.set == "Booster" or obj.jumbo_mod then
+        if obj.set == "Booster" or obj.jumbo_mod then
-			jumbo_modifier = obj.jumbo_mod or 10
+            jumbo_modifier = obj.jumbo_mod or 10
-		end
+        end
 
-		if card.added_to_deck then
+        if card.added_to_deck then
-			card:remove_from_deck()
+            card:remove_from_deck()
-		end
+        end
 
-		Jane.misprintize(card, {min = jumbo_modifier, max = jumbo_modifier}, nil, true)
+        Jane.misprintize(card, {min = jumbo_modifier, max = jumbo_modifier}, nil, true)
 
-		if card.added_to_deck then
+        if card.added_to_deck then
-			card:add_to_deck()
+            card:add_to_deck()
-		end
+        end
-	end,
+    end,
-	on_remove = function(card)
+    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()
-				resize(card, 1 / Jane.config.wee_sizemod)
-				return true
-			end
-		}))
 
-		local was_added = card.added_to_deck
+        local was_added = card.added_to_deck
 
-		if was_added then
+        if was_added then
-			card:remove_from_deck()
+            card:remove_from_deck()
-		end
+        end
 
-		Jane.misprintize(card, {min = 1 / jumbo_modifier, max = 1 / jumbo_modifier}, nil, true)
+        Jane.misprintize(card, {min = 1 / jumbo_modifier, max = 1 / jumbo_modifier}, nil, true)
 
-		if was_added then
+        if was_added then
-			card:add_to_deck()
+            card:add_to_deck()
-		end
+        end
-	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,
+    in_shop = true,
-		vol = 0.5
+    shader = false,
-	},
+    apply_to_float = false,
-	weight = 0.8,
+    get_weight = get_weight,
-	in_shop = true,
+})
-	shader = false,
+
-	extra_cost = 12,
+SMODS.Edition({
-	apply_to_float = false,
+    key = "moire",
-	get_weight = function(self)
+    loc_txt = {
-		return G.GAME.edition_rate * self.weight
+        name = "Moire",
-	end,
+        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

@@ -1,48 +1,52 @@
-for _, v in pairs({"7granddad", "betmma", "oxy", "peppino"}) do
+for _, v in pairs({"7granddad", "betmma", "honey", "oxy", "maxie", "peppino"}) do
-	SMODS.Atlas {
+    SMODS.Atlas {
-		px = 71,
+        px = 71,
-		py = 95,
+        py = 95,
-		key = "jane" .. v,
+        key = "jane" .. v,
-		path = Jane.config.texture_pack .. "/j_jane_" .. v .. ".png",
+        path = Jane.config.texture_pack .. "/j_jane_" .. v .. ".png",
-	}
+    }
 end
 
 for i = 1, 6 do
-	SMODS.Sound({key = 'grand' .. i, path = 'grand_dad' .. i .. '.ogg'})
+    SMODS.Sound({key = "grand" .. i, path = "grand_dad" .. i .. ".ogg"})
 end
 
+SMODS.Sound({key = "corrupt_milestone", path = "corrupt_milestone.ogg"})
+SMODS.Sound({key = "corrupt_untick", path = "corrupt_untick.ogg"})
+SMODS.Sound({key = "corrupt_tick", path = "corrupt_tick.ogg"})
+
 local exotic = Cryptid and "cry_exotic" or 4
 
 local food = {
-	"j_gros_michel",
+    "j_gros_michel",
-	"j_egg",
+    "j_egg",
-	"j_ice_cream",
+    "j_ice_cream",
-	"j_cavendish",
+    "j_cavendish",
-	"j_turtle_bean",
+    "j_turtle_bean",
-	"j_diet_cola",
+    "j_diet_cola",
-	"j_popcorn",
+    "j_popcorn",
-	"j_ramen",
+    "j_ramen",
-	"j_selzer",
+    "j_selzer",
-	"j_cry_pickle",
+    "j_cry_pickle",
-	"j_cry_chili_pepper",
+    "j_cry_chili_pepper",
-	"j_cry_oldcandy",
+    "j_cry_oldcandy",
-	"j_cry_caramel",
+    "j_cry_caramel",
-	"j_cry_foodm",
+    "j_cry_foodm",
-	"j_cry_cotton_candy",
+    "j_cry_cotton_candy",
-	"j_cry_wrapped",
+    "j_cry_wrapped",
-	"j_cry_candy_cane",
+    "j_cry_candy_cane",
-	"j_cry_candy_buttons",
+    "j_cry_candy_buttons",
-	"j_cry_jawbreaker",
+    "j_cry_jawbreaker",
-	"j_cry_mellowcreme",
+    "j_cry_mellowcreme",
-	"j_cry_brittle",
+    "j_cry_brittle",
-	"j_jane_peppino",
+    "j_jane_peppino",
 }
 
 local granddad_palette = {
-	HEX("155fd9"),
+    HEX("155fd9"),
-	HEX("ff8170"),
+    HEX("ff8170"),
-	HEX("ffffff"),
+    HEX("ffffff"),
-	HEX("6c0700")
+    HEX("6c0700"),
 }
 
 local function food_jokers_count()
@@ -50,231 +54,551 @@ local function food_jokers_count()
         return 0
     end
 
-	local amount = 0
+    local amount = 0
 
     for _, v in pairs(food) do
         amount = amount + #SMODS.find_card(v)
     end
 
-	return amount
+    return amount
 end
 
 local function grand_dad(card)
-	Jane.q(function()
+    if ((Talisman or {}).config_file or {}).disable_anims then
-		card:juice_up(0.5, 0.5)
+        return
-		return true
+    end
-	end)
 
-	local rnd = math.random(6)
+    Jane.q(function()
-	local obj = card.edition or {}
+        card:juice_up(0.5, 0.5)
+    end)
 
-	Jane.play_sound(
+    local rnd = math.random(6)
-		"jane_grand" .. rnd,
+    local obj = card.edition or {}
-		obj.jane_jumbo and (1 / Jane.config.wee_sizemod) or 1,
-		0.5
-	)
 
-	Jane.card_status_text(
+    Jane.play_sound(
-		card,
+        "jane_grand" .. rnd,
-		rnd == 2 and "Flintstones?!" or rnd == 6 and "Gruhh- Dad!" or "Grand Dad!",
+        obj.jane_jumbo and (1 / Jane.config.wee_sizemod) or 1,
-		nil,
+        0.5
-		0.05 * card.T.h,
+    )
-		granddad_palette[math.random(#granddad_palette)],
+
-		0.6,
+    Jane.card_status_text(
-		0.6,
+        card,
-		nil,
+        rnd == 2 and "Flintstones?!" or rnd == 6 and "Gruhh- Dad!" or "Grand Dad!",
-		nil,
+        nil,
-		"bm"
+        0.05 * card.T.h,
-	)
+        granddad_palette[math.random(#granddad_palette)],
+        0.6,
+        0.6,
+        nil,
+        nil,
+        "bm"
+    )
 end
 
 local function voucher_count()
-	if not G.GAME.used_vouchers then
+    if not G.GAME.used_vouchers then
-		return 0
+        return 0
-	end
+    end
 
-	local count = 0
+    local count = 0
 
-	for _, v in pairs(G.GAME.used_vouchers) do
+    for _, v in pairs(G.GAME.used_vouchers) do
-		if v then
+        if v then
-			count = count + 1
+            count = count + 1
-		end
+        end
-	end
+    end
 
-	return count
+    return count
+end
+
+local maxie_quotes = {
+    normal = {
+        "Hey! I hope we can become great friends together!",
+        "Need a paw?",
+        "Together as a team!",
+        "Mmm... Milk sounds good right about now.",
+        "Unlike most other bunnies; I don't like carrots.",
+        "Mmm... Mac and Cheese...",
+        "I am just sitting here.",
+    },
+    scared = {
+        "A-ah! S-stop it, please!! You're scaring me...!",
+        "E-eek! B-be careful!!",
+    },
+}
+
+local maxie_limit = 25
+
+SMODS.Joker {
+    key = "maxie",
+    atlas = "janemaxie",
+    loc_txt = {
+        name = "Maxie",
+        text = {
+            "{C:attention}+#1# {}booster pack slot#2#",
+            "{C:inactive,s:0.75,E:1}#3#{C:red,s:1.5,E:1}#4#",
+        },
+    },
+    config = {extra = {choices = Cryptid and 2 or 1}},
+    pos = {x = 0, y = 0},
+    sinis = {x = 2, y = 0},
+    soul_pos = {x = 1, y = 0},
+    cost = 6,
+    rarity = 2,
+    loc_vars = function(_, _, card)
+        return {
+            vars = {
+                card.ability.extra.choices,
+                card.ability.extra.choices == 1 and "" or "s",
+                Jane.sinister and "" or pseudorandom_element(maxie_quotes.normal, pseudoseed("MaxieQuotes")),
+                Jane.sinister and pseudorandom_element(maxie_quotes.scared, pseudoseed("MaxieQuotes")) or "",
+            },
+        }
+    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, min do
+                SMODS.add_booster_to_shop()
+            end
+        end
+    end,
+}
+
+function Jane.update_honey()
+    if not G.GAME then
+        return
+    end
+
+    local honey = SMODS.find_card("j_jane_honey")
+    local mergeable = {}
+    local max = 1
+
+    for _, v in pairs(honey) do
+        local level = tonumber(v.ability.extra.level) or 1
+        max = math.max(max, level)
+
+        if not mergeable[level] then
+            mergeable[level] = v
+        elseif level == 1 then
+            mergeable[0] = v
+        end
+    end
+
+    for i = math.min(max, #Jane.rarity_ids - 2), 1, -1 do
+        if not mergeable[i] then
+            goto continue
+        end
+
+        local skip = true
+
+        for j = i - 1, i == 1 and 0 or 1, -1 do
+            if not mergeable[j] then
+                break
+            end
+
+            skip = j > 1
+        end
+
+        if skip then
+            goto continue
+        end
+
+        for j = i - 1, i == 1 and 0 or 1, -1 do
+            mergeable[i].sell_cost = mergeable[i].sell_cost + mergeable[j].sell_cost
+            mergeable[j].ability.extra.level = "-1"
+            mergeable[j]:start_dissolve()
+        end
+
+        mergeable[i].ability.extra.level = tostring(tonumber(mergeable[i].ability.extra.level) + 1)
+        play_sound("jane_corrupt_milestone", 0.9 ^ (tonumber(mergeable[i].ability.extra.level) - 2))
+        ::continue::
+    end
 end
 
 SMODS.Joker {
-	key = "oxy",
+    key = "honey",
-	atlas = "janeoxy",
+    atlas = "janehoney",
-	loc_txt = {
+    loc_txt = {
-		name = "Oxy",
+        name = "Honey{C:dark_edition}#1#",
-		text = {
+        text = {
-			"{C:attention}Scored steel{} cards give",
+            "{C:attention}#2#{}#3#",
-			"{X:mult,C:white}x#1#{} {C:mult}Mult {}& {X:chips,C:white}x#1#{} {C:chips}Chips",
+            "#4#cannot appear",
-			" ",
+            "#5#{C:attention}#6#",
-			"{C:inactive,s:0.75,E:1}#2#{C:red,s:1.5,E:1}#3#",
+            "{C:dark_edition}#7#{}#8#{C:inactive,s:0.75,E:1}#9#",
-		}
+            "{C:inactive,s:0.75,E:1}#10#{C:red,s:1.5,E:1}#11#",
-	},
+        },
-	pos = {x = 0, y = 0},
+    },
-	config = {steel = 1.5},
+    config = {extra = {level = "1"}}, -- Strings do not get mutated by other mods
-	sinis = {x = 2, y = 0},
+    pos = {x = 0, y = 0},
-	soul_pos = {x = 1, y = 0},
+    sinis = {x = 2, y = 0},
-	cost = 10,
+    soul_pos = {x = 1, y = 0},
-	rarity = 3,
+    eternal_compat = false,
-	blueprint_compat = true,
+    cost = 8,
-    loc_vars = function(_, _, center)
+    rarity = 3,
-        return {vars = {
+    loc_vars = function(_, _, card)
-			center.ability.steel,
+        local level = tonumber(card.ability.extra.level)
-			Jane.sinister and "" or "We all cut close...",
+
-			Jane.sinister and "WHAT ARE YOU DOING DOWN THERE?!?" or "",
+        local function level_name(i)
-		}}
+            local acc = ""
+            local prefixes = {"super", "hyper", "ultra"}
+
+            while i > 0 do
+                acc = prefixes[((i - 1) % 3) + 1] .. acc
+                i = math.floor(i / 3)
+            end
+
+            return #acc == 0 and "Corrupted" or acc:gsub("^%l", string.upper) .. "corrupted"
+        end
+
+        local is_corrupted = level > 1
+        local exclusions = is_corrupted and "" or Jane.rarity_names[level]
+        local separator = level == 2 and " " or (is_corrupted and ", " or "")
+
+        if is_corrupted then
+            for i = 1, level do
+                exclusions = exclusions .. separator .. (i == level and "and " or "") .. Jane.rarity_names[i]
+            end
+        end
+
+        return {
+            vars = {
+                is_corrupted and " (" .. level_name(level - 2) .. ")" or "",
+                (exclusions or ""):sub(#separator),
+                is_corrupted and "" or " jokers",
+                is_corrupted and "jokers " or "",
+                is_corrupted and (level >= #Jane.rarity_names - 1 and "Cannot be upgraded." or "") or "Getting another ",
+                is_corrupted and "" or "Honey",
+                is_corrupted and "" or "corrupts ",
+                is_corrupted and "" or "this Joker",
+                Jane.sinister and "" or (is_corrupted and "*Her eyes are looking around," or ""),
+                Jane.sinister and "" or
+                (is_corrupted and "as if she wants to say something...*" or "Buzzzzz! I'll do my best!"),
+                Jane.sinister and (is_corrupted and "..." or "S-STOP THAT!! YOU'RE FREAKING ME OOOUT!!!") or "",
+            },
+        }
+    end,
+    update = function(_, card, _)
+        if card.added_to_deck and card.children.center and card.children.floating_sprite then
+            local extra = card.ability.extra or {}
+            local y = tonumber(extra.level) > 1 and 1 or 0
+            card.children.center:set_sprite_pos({x = 0, y = y})
+            card.children.floating_sprite:set_sprite_pos({x = Jane.sinister and 2 or 1, y = y})
+        end
+
+        local level = tonumber(card.ability.extra.level)
+
+        if not Jane.sinister and level > 2 then
+            card:juice_up(0, math.random() * (level - 2) / #Jane.rarity_ids)
+        end
     end,
-    calculate = function(self, card, context)
-		if context.individual and
-			context.cardarea == G.play and
-			context.other_card.ability.name == "Steel Card" then
-			return {
-				x_chips = card.ability.steel,
-				x_mult = card.ability.steel,
-				colour = G.C.PURPLE,
-				card = card
-			}, true
-		end
-	end
 }
 
+if Cryptid then
+    Cryptid.aliases["honey"] = "j_jane_honey"
+end
+
+local orig_rarity = SMODS.poll_rarity
+
+function SMODS.poll_rarity(_pool_key, _rand_key)
+    local max = 0
+
+    for _, v in pairs(SMODS.find_card("j_jane_honey")) do
+        max = v.debuff and max or math.max(max, v.ability.extra.level)
+    end
+
+    local rarity = orig_rarity(_pool_key, _rand_key)
+
+    for i = 1, max do
+        if rarity == Jane.rarity_ids[i] then
+            return Jane.rarity_ids[max + 1] or Jane.rarity_ids[#Jane.rarity_ids]
+        end
+    end
+
+    return rarity
+end
+
+local oxy_quotes = {
+    normal = {
+        "YOU WILL LOSE",
+        "DON'T EVEN TRY",
+        "WE WILL STOP YOU",
+        "He glares at the blinds with conviction.",
+    },
+    scared = {
+        "...H-how are you doing t-that...?",
+        "This is... unsettling...",
+        "S-... So much power...",
+    },
+}
+
+function Jane.oxy(card, removed)
+    local extra = card.ability.extra or {}
+    local destroyed_steel = 0
+
+    for _, v in pairs(removed or {}) do
+        if (v.ability or {}).name == "Steel Card" then
+            destroyed_steel = destroyed_steel + 1
+        end
+    end
+
+    if destroyed_steel > 0 then
+        extra.progress = extra.progress + destroyed_steel
+        play_sound("jane_corrupt_tick")
+
+        card_eval_status_text(
+            card,
+            "extra",
+            nil,
+            nil,
+            nil,
+            {
+                message = (extra.is_corrupted and "+" or "-") .. destroyed_steel,
+                colour = extra.is_corrupted and G.C.PURPLE or G.C.GREY,
+            }
+        )
+    end
+end
+
+local steel = 2
+
 SMODS.Joker {
-	key = "7granddad",
+    key = "oxy",
-	loc_txt = {
+    atlas = "janeoxy",
-		name = "7 GRAND DAD",
+    loc_txt = {
-		text = {
+        name = "Oxy{C:dark_edition}#1#",
-			"This Joker has a {C:jane_RGB,E:1}strange",
+        text = {
-			"{C:jane_RGB,E:1}reaction {}to scored {C:attention}7{}s",
+            "{C:attention}Scored steel {}cards",
-		}
+            "give {X:mult,C:white}X#2#{} {C:mult}Mult",
-	},
+            "{C:dark_edition,E:1}#3#{}#4#{C:red}#5#{C:attention}#6#",
-	config = {},
+            "{C:dark_edition,E:1}#7#{}#8#",
-	pos = {x = 0, y = 0},
+            "#9#{C:dark_edition,E:1}#10#",
-	soul_pos = {x = 1, y = 0},
+            "{C:inactive,s:0.75,E:1}#11#{C:red,s:1.5,E:1}#12#",
-	cost = 12,
+        },
-	rarity = exotic,
+    },
-	atlas = "jane7granddad",
+    config = {extra = {corrupted_steel = 6, is_corrupted = false, milestone = 3, progress = 0}},
-	blueprint_compat = true,
+    pos = {x = 0, y = 0},
-    loc_vars = function(_, _, center)
+    sinis = {x = 2, y = 0},
-        return {vars = {center.ability.shopslots}}
+    soul_pos = {x = 1, y = 0},
+    blueprint_compat = true,
+    cost = Cryptid and 8 or 20,
+    rarity = Cryptid and 3 or 4,
+    loc_vars = function(_, info_queue, card)
+        info_queue[#info_queue + 1] = G.P_CENTERS.m_steel
+        local ability = card.ability.extra or {}
+        local milestone = ability.milestone
+        local progress = ability.progress
+        local is_corrupted = ability.is_corrupted
+        local amount = is_corrupted and ability.corrupted_steel or steel
+        local effective = is_corrupted and progress or milestone - progress
+        local plural = effective == 1 and "" or "s"
+
+        return {
+            vars = {
+                is_corrupted and " (Corrupted)" or "",
+                amount,
+                is_corrupted and "Purifies " or "",
+                is_corrupted and "in " or "",
+                is_corrupted and "" or "Destroying ",
+                effective .. (is_corrupted and " round" or " steel card") .. plural,
+                is_corrupted and "" or "corrupts ",
+                is_corrupted and "Destroying steel cards" or "this Joker",
+                is_corrupted and "prolongs the " or "",
+                is_corrupted and "corruption" or "",
+                Jane.sinister and "" or
+                (is_corrupted and pseudorandom_element(oxy_quotes.normal, pseudoseed("OxyQuotes")) or "We all cut close..."),
+                Jane.sinister and
+                (is_corrupted and pseudorandom_element(oxy_quotes.scared, pseudoseed("OxyQuotes")) or "WHAT ARE YOU DOING DOWN THERE?!?") or
+                "",
+            },
+        }
+    end,
+    update = function(_, card, _)
+        if card.added_to_deck and card.children.center and card.children.floating_sprite then
+            local extra = card.ability.extra or {}
+            local y = extra.is_corrupted and 1 or 0
+            card.children.center:set_sprite_pos({x = 0, y = y})
+            card.children.floating_sprite:set_sprite_pos({x = Jane.sinister and 2 or 1, y = y})
+        end
     end,
-	add_to_deck = function(_, card, _)
-		grand_dad(card)
-	end,
-	remove_from_deck = function(_, card, _)
-		grand_dad(card)
-	end,
     calculate = function(_, card, context)
-		if context.cardarea == G.play then
+        local extra = card.ability.extra or {}
-			local function scj(c)
+        Jane.oxy(card, context.removed)
-				return c.cardarea and c.cardarea == G.play and not c.before and not c.after and not c.repetition
-			end
 
-			if context.other_card and context.other_card:get_id() == 7 and scj(context) then
+        if context.end_of_round and
-				grand_dad(card)
+            extra.progress > 0 and not
-				local palette = granddad_palette[math.random(#granddad_palette)]
+            context.individual and not
-				local rnd = pseudorandom(pseudoseed("granddad"), 1, Cryptid and 7 or 5)
+            context.repetition and not
+            context.retrigger_joker then
+            play_sound("jane_corrupt_untick")
+            extra.progress = extra.progress - 1
 
-				if rnd == 1 then
+            card_eval_status_text(
-					return {
+                card,
-						message = "+777",
+                "extra",
-						chips = 777,
+                nil,
-						colour = palette,
+                nil,
-						card = card
+                nil,
-					}, true
+                {
-				elseif rnd == 2 then
+                    message = extra.is_corrupted and "-1" or "+1",
-					return {
+                    colour = extra.is_corrupted and G.C.PURPLE or G.C.GREY,
-						message = "+777 Mult",
+                }
-						mult = 777,
+            )
-						colour = palette,
+        end
-						card = card
+
-					}, true
+        if not extra.is_corrupting and
-				elseif rnd == 3 then
+            ((extra.progress >= extra.milestone and not extra.is_corrupted) or
-					return {
+                (extra.progress <= 0 and extra.is_corrupted)) then
-						message = "+$7",
+            extra.is_corrupting = true
-						dollars = 7,
+
-						colour = palette,
+            Jane.q(function()
-						card = card
+                card:flip()
-					}, true
+                play_sound("card1")
-				elseif rnd == 4 then
+            end, 0.1)
-					return {
+
-						message = "x7",
+            Jane.q(function()
-						x_chips = 7,
+                card:flip()
-						colour = palette,
+                card:juice_up(1, 1)
-						card = card
+                play_sound("card1")
-					}, true
+                play_sound("jane_corrupt_milestone")
-				elseif rnd == 5 then
+                extra.is_corrupted = not extra.is_corrupted
-					return {
+                extra.is_corrupting = nil
-						message = "x7 Mult",
+            end, 1)
-						x_mult = 7,
+        end
-						colour = palette,
+
-						card = card
+        if context.individual and
-					}, true
+            context.cardarea == G.play and
-				elseif rnd == 6 then
+            context.other_card.ability.name == "Steel Card" then
-					return {
+            local amount = extra.is_corrupted and extra.corrupted_steel or steel
-						message = "^1.77",
+            return {x_mult = amount, colour = G.C.PURPLE, card = card}, true
-						e_chips = 1.77,
+        end
-						colour = palette,
+    end,
-						card = card
-					}, true
-				else
-					return {
-						message = "^1.77 Mult",
-						e_mult = 1.77,
-						colour = palette,
-						card = card
-					}, true
-				end
-			end
-		end
-	end
 }
 
-local operator = Cryptid and "^" or "*"
+if Cryptid then
+    Cryptid.aliases["oxy"] = "j_jane_oxy"
+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",
+    key = "betmma",
-	atlas = "janebetmma",
+    atlas = "janebetmma",
-	loc_txt = {
+    loc_txt = {
-		name = "Betmma",
+        name = "Betmma",
-		text = {
+        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: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 = 0.1}},
+    config = {extra = {tet = Cryptid and 0.25 or 0.5}},
-	pos = {x = 0, y = 0},
+    pos = {x = 0, y = 0},
-	soul_pos = {x = 1, y = 0},
+    soul_pos = {x = 1, y = 0},
-	cost = 50,
+    blueprint_compat = true,
-	rarity = exotic,
+    cost = Cryptid and 20 or 8,
-	blueprint_compat = true,
+    rarity = Cryptid and 4 or 3,
     loc_vars = function(_, _, center)
         return {vars = {center.ability.extra.tet, 1 + (voucher_count() * center.ability.extra.tet)}}
     end,
     calculate = function(_, card, context)
-		if context.cardarea ~= G.jokers or context.before or context.after or not context.scoring_name then
+        if not context.joker_main then
-			return
+            return
-		end
+        end
 
-		local v = voucher_count()
+        local v = voucher_count()
 
-		if v > 0 then
+        if v > 0 then
-			local num = 1 + (v * card.ability.extra.tet)
+            local num = 1 + (v * card.ability.extra.tet)
 
-			return {
+            return {
-				card = card,
+                card = card,
-				colour = G.C.jane_RGB,
+                colour = G.C.jane_RGB,
-				message = operator .. number_format(num),
+                message = operator .. number_format(num),
-				[Cryptid and "Echips_mod" or "xchips_mod"] = num,
+                [Cryptid and "e_mult" or "x_mult"] = num,
-			}, true
+            }, true
-		end
+        end
-	end
+    end,
+}
+
+SMODS.Joker {
+    key = "7granddad",
+    loc_txt = {
+        name = "7 GRAND DAD",
+        text = {
+            "This Joker has a {C:jane_RGB,E:1}strange",
+            "{C:jane_RGB,E:1}reaction {}to scored {C:attention}7{}s",
+        },
+    },
+    config = {},
+    pos = {x = 0, y = 0},
+    soul_pos = {x = 1, y = 0},
+    atlas = "jane7granddad",
+    blueprint_compat = true,
+    cost = Cryptid and 49 or 7,
+    rarity = Cryptid and exotic or 3,
+    loc_vars = function(_, _, center)
+        return {vars = {center.ability.shopslots}}
+    end,
+    add_to_deck = function(_, card, _)
+        grand_dad(card)
+    end,
+    remove_from_deck = function(_, card, _)
+        grand_dad(card)
+    end,
+    calculate = function(_, card, context)
+        if context.cardarea == G.play then
+            local function scj(c)
+                return c.cardarea and c.cardarea == G.play and not c.before and not c.after and not c.repetition
+            end
+
+            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 5 or 4)
+
+                if rnd == 1 then
+                    return {
+                        message = Cryptid and "+777" or "+77",
+                        chips = Cryptid and 777 or 77,
+                        colour = palette,
+                        card = card,
+                    }, true
+                elseif rnd == 2 then
+                    return {
+                        message = Cryptid and "+777 Mult" or "+77 Mult",
+                        mult = Cryptid and 777 or 77,
+                        colour = palette,
+                        card = card,
+                    }, true
+                elseif rnd == 3 then
+                    return {
+                        message = "+$7",
+                        dollars = 7,
+                        colour = palette,
+                        card = card,
+                    }, true
+                elseif rnd == 4 then
+                    return {
+                        message = Cryptid and "X7 Mult" or "X1.77 Mult",
+                        x_mult = Cryptid and 7 or 1.77,
+                        colour = palette,
+                        card = card,
+                    }, true
+                else
+                    return {
+                        message = "^1.77 Mult",
+                        e_mult = 1.77,
+                        colour = palette,
+                        card = card,
+                    }, true
+                end
+            end
+        end
+    end,
 }
 
 SMODS.Joker {
@@ -283,29 +607,30 @@ 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",
+            "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},
-    cost = 50,
+    config = {extra = {base = 2}},
     rarity = exotic,
-	blueprint_compat = true,
+    blueprint_compat = true,
-    loc_vars = function(_, _, _)
+    cost = Cryptid and 50 or 20,
-        return {vars = {2 ^ food_jokers_count()}}
+    loc_vars = function(_, _, card)
+        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,
+                colour = G.C.DARK_EDITION,
-                message = "^" .. 2 ^ count .. " Mult",
+                message = operator .. card.ability.extra.base ^ count .. " Mult",
-                [Cryptid and "Emult_mod" or "xmult_mod"] = 2 ^ count,
+                [Cryptid and "e_mult" or "x_mult"] = card.ability.extra.base ^ count,
             }, true
         end
-    end
+    end,
 }

src/main.lua

@@ -1,139 +1,143 @@
 Jane = {
-	config = {
+    config = {
-		wee_sizemod = 1.25,
+        wee_sizemod = 1.25,
-		texture_pack = "default",
+        texture_pack = "default",
-		bans = {"j_cry_crustulum", "c_cry_hammerspace"}
+        bans = {"j_cry_crustulum", "c_cry_hammerspace"},
-	},
+    },
 }
 
 Jane.misprintize = (Cryptid or {}).misprintize
 Jane.misprintize_tbl = (Cryptid or {}).misprintize_tbl
 Jane.misprinitze_val = (Cryptid or {}).misprintize_val
+Jane.rarity_ids = Cryptid and {1, 2, 3, "cry_epic", 4, "cry_exotic", "jane_junk"} or {1, 2, 3, 4, "jane_junk"}
+
+Jane.rarity_names = Cryptid and {"Common", "Uncommon", "Rare", "Epic", "Legendary", "Exotic", "Junk"} or
+    {"Common", "Uncommon", "Rare", "Legendary", "Junk"}
 
 if not Jane.misprintize then
-	assert(SMODS.load_file("src/misprintize.lua"))()
+    assert(SMODS.load_file("src/misprintize.lua"))()
 end
 
-function Jane.canuse()
+function Jane.can_use()
-	return not (((G.play and #G.play.cards > 0) or
+    return not (((G.play and #G.play.cards > 0) or
-		(G.CONTROLLER.locked) or
+            (G.CONTROLLER.locked) or
-		(G.GAME.STOP_USE and G.GAME.STOP_USE > 0)) and
+            (G.GAME.STOP_USE and G.GAME.STOP_USE > 0)) and
-		G.STATE ~= G.STATES.HAND_PLAYED and
+        G.STATE ~= G.STATES.HAND_PLAYED and
-		G.STATE ~= G.STATES.DRAW_TO_HAND and
+        G.STATE ~= G.STATES.DRAW_TO_HAND and
-		G.STATE ~= G.STATES.PLAY_TAROT)
+        G.STATE ~= G.STATES.PLAY_TAROT)
 end
 
 function Jane.card_status_text(
-	card,
+    card,
-	text,
+    text,
-	xoffset,
+    xoffset,
-	yoffset,
+    yoffset,
-	colour,
+    colour,
-	size,
+    size,
-	delay,
+    delay,
-	juice,
+    juice,
-	jiggle,
+    jiggle,
-	align,
+    align,
-	sound,
+    sound,
-	volume,
+    volume,
-	pitch,
+    pitch,
-	trig,
+    trigger,
-	f
+    f
 )
-	if (delay or 0) <= 0 then
+    if (delay or 0) <= 0 then
-		if type(f) == "function" then
+        if type(f) == "function" then
-			f(card)
+            f(card)
-		end
+        end
 
-		attention_text({
+        attention_text({
-			text = text,
+            text = text,
-			scale = size or 1,
+            scale = size or 1,
-			hold = 0.7,
+            hold = 0.7,
-			backdrop_colour = colour or (G.C.FILTER),
+            backdrop_colour = colour or (G.C.FILTER),
-			align = align or "bm",
+            align = align or "bm",
-			major = card,
+            major = card,
-			offset = {x = xoffset or 0, y = yoffset or (-0.05*G.CARD_H)}
+            offset = {x = xoffset or 0, y = yoffset or (-0.05 * G.CARD_H)},
-		})
+        })
 
-		if sound then
+        if sound then
-			play_sound(sound, pitch or (0.9 + (0.2 * math.random())), volume or 1)
+            play_sound(sound, pitch or (0.9 + (0.2 * math.random())), volume or 1)
-		end
+        end
 
-		if juice then
+        if juice then
-			if type(juice) == "table" then
+            if type(juice) == "table" then
-				card:juice_up(juice[1], juice[2])
+                card:juice_up(juice[1], juice[2])
-			elseif type(juice) == "number" and juice ~= 0 then
+            elseif type(juice) == "number" and juice ~= 0 then
-				card:juice_up(juice, juice / 6)
+                card:juice_up(juice, juice / 6)
-			end
+            end
-		end
+        end
 
-		if jiggle then
+        if jiggle then
-			G.ROOM.jiggle = G.ROOM.jiggle + jiggle
+            G.ROOM.jiggle = G.ROOM.jiggle + jiggle
-		end
+        end
-	else
+    else
-		G.E_MANAGER:add_event(Event({
+        Jane.q(
-			trigger = trig,
+            function()
-			delay = delay,
+                if f and type(f) == "function" then
-			func = function()
+                    f(card)
-				if f and type(f) == "function" then
+                end
-					f(card)
-				end
 
-				attention_text({
+                attention_text({
-					text = text,
+                    text = text,
-					scale = size or 1,
+                    scale = size or 1,
-					hold = 0.7 + (delay or 0),
+                    hold = 0.7 + (delay or 0),
-					backdrop_colour = colour or (G.C.FILTER),
+                    backdrop_colour = colour or (G.C.FILTER),
-					align = align or "bm",
+                    align = align or "bm",
-					major = card,
+                    major = card,
-					offset = {x = xoffset or 0, y = yoffset or (-0.05*G.CARD_H)}
+                    offset = {x = xoffset or 0, y = yoffset or (-0.05 * G.CARD_H)},
-				})
+                })
 
-				if sound then
+                if sound then
-					play_sound(sound, pitch or (0.9 + (0.2*math.random())), volume or 1)
+                    play_sound(sound, pitch or (0.9 + (0.2 * math.random())), volume or 1)
-				end
+                end
 
-				if juice then
+                if juice then
-					if type(juice) == "table" then
+                    if type(juice) == "table" then
-						card:juice_up(juice[1], juice[2])
+                        card:juice_up(juice[1], juice[2])
-					elseif type(juice) == "number" and juice ~= 0 then
+                    elseif type(juice) == "number" and juice ~= 0 then
-						card:juice_up(juice, juice / 6)
+                        card:juice_up(juice, juice / 6)
-					end
+                    end
-				end
+                end
 
-				if jiggle then
+                if jiggle then
-					G.ROOM.jiggle = G.ROOM.jiggle + jiggle
+                    G.ROOM.jiggle = G.ROOM.jiggle + jiggle
-				end
+                end
-
+            end,
-				return true
+            delay,
-			end
+            nil,
-		}))
+            trigger
-	end
+        )
+    end
 end
 
 function Jane.empowered()
-	if Cryptid then
+    if Cryptid then
-		add_tag(Tag("tag_cry_empowered"))
+        add_tag(Tag("tag_cry_empowered"))
-		return true
+        return
-	end
+    end
 
-	local card = create_card("Spectral", G.consumeables, nil, nil, nil, nil, "c_soul", "acceleration_soul")
+    local card = create_card("Spectral", G.consumeables, nil, nil, nil, nil, "c_soul", "acceleration_soul")
-	card:set_edition({negative = true})
+    card:set_edition({negative = true})
-	card:add_to_deck()
+    card:add_to_deck()
-	G.consumeables:emplace(card)
+    G.consumeables:emplace(card)
 end
 
 function Jane.get_chipmult_sum(chips, mult)
-	chips = chips or 0
+    chips = chips or 0
-	mult = mult or 0
+    mult = mult or 0
 
-    local op, big = Jane.get_operator(), Talisman.config_file.break_infinity == "omeganum" and
+    local break_infinity = ((Talisman or {}).config_file or {}).break_infinity
-        to_big or function (x) return x end
+    local big = (break_infinity == "" or break_infinity == nil) and function(x) return x end or to_big
+    local op = Jane.get_operator()
 
-	if op >= 3 then
+    if op >= 3 then
-		return big(chips) ^ big(mult)
+        return big(chips) ^ big(mult)
-	elseif op == 2 then
+    elseif op == 2 then
-		return big(chips) * big(mult)
+        return big(chips) * big(mult)
     end
 
     return big(chips) + big(mult)
@@ -149,143 +153,98 @@ function Jane.get_operator()
 end
 
 function Jane.hidden(card)
-	return G.GAME and not
+    return G.GAME and not G.GAME.obsidian and
-		G.GAME.obsidian and
+        (type(card) == "table" and (card.name == "Black Hole" or card.name == "The Soul") or card.hidden)
-		type(card) == 'table' and
+end
-		(card.name == "Black Hole" or card.name == "The Soul" or card.hidden)
+
+function Jane.is_end_of_ante(context, card)
+    return not context.individual and not
+        context.repetition and not
+        (card or {}).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
 
 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.q(fc, de, t, tr, bl, ba)
+function Jane.resize(card, mod, force_save)
-	G.E_MANAGER:add_event(Event({
+    if force_save or not card.origsize then
-		timer = t,
+        card.origsize = {w = card.T.w, h = card.T.h}
-		trigger = tr,
+    end
-		delay = de,
+
-		blockable = bl,
+    card:hard_set_T(card.T.x, card.T.y, card.T.w * mod, card.T.h * mod)
-		blocking = ba,
+    remove_all(card.children)
-		func = fc
+    card.children = {}
-	}))
+    card.children.shadow = Moveable(0, 0, 0, 0)
+    card:set_sprites(card.config.center, card.base.id and card.config.card)
+
+    if card.area and
+        ((G.shop_jokers and card.area == G.shop_jokers) or
+            (G.shop_booster and card.area == G.shop_booster) or
+            (G.shop_vouchers and card.area == G.shop_vouchers)) then
+        create_shop_card_ui(card)
+    end
+end
+
+function Jane.q(func, delay, timer, trigger, blockable, blocking)
+    G.E_MANAGER:add_event(Event({
+        delay = delay,
+        timer = timer,
+        trigger = (delay and not trigger) and "after" or trigger,
+        blocking = blocking,
+        blockable = blockable,
+        func = function(...)
+            local ret = func(...)
+            return ret == nil and true or ret
+        end,
+    }))
 end
 
 function Card:gc()
-	return (self.config or {}).center or {}
+    return (self.config or {}).center or {}
 end
 
 function Card:norank()
-	return self.ability.name == "Stone Card" or self.config.center.no_rank
+    return self.ability.name == "Stone Card" or self.config.center.no_rank
 end
 
 function Card:nosuit()
-	return self.ability.name == "Stone Card" or self.config.center.no_suit
+    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)
-	Jane.sinister = nil
+    Jane.sinister = nil
-	orig_menu(self, change_context)
+    orig_menu(self, change_context)
 end
 
 local orig_update = Game.update
 
 function Game:update(dt)
-	local function delete_hardbans()
+    local function delete_hardbans()
-		if not Jane.config.disable_bans then
+        if not Jane.config.disable_bans then
-			for _, v in pairs(Jane.config.bans) do
+            for _, v in pairs(Jane.config.bans) do
-				local e = SMODS.Center:get_obj(v)
+                local e = SMODS.Center:get_obj(v)
 
-				if e then
+                if e then
-					e:delete()
+                    e:delete()
-				end
+                end
-			end
+            end
-		end
+        end
-	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 pools = {chips = 0, level = 0, mult = 0}
-
-		for k, v in pairs(G.GAME.hands) do
-			if k ~= "cry_WholeDeck" then
-				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
-		end
-
-		if pools.mult == orrery.mult and pools.chips == orrery.chips and pools.level == orrery.level then
-			return
-		end
-
-		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
-
-		orrery.mult = pools.mult
-		orrery.chips = pools.chips
-		orrery.level = pools.level
-		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
         local x = (1 - math.abs((h % 2) - 1)) * c
@@ -308,66 +267,60 @@ function Game:update(dt)
         return r + m, g + m, b + m
     end
 
-	orig_update(self, dt)
+    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
+    G.P_BLINDS["bl_jane_descending"].mult = math.floor(8 * math.sqrt(blind)) / blind
+    Jane.update_honey()
 
-	if not Jane.bans_done then
+    if not Jane.bans_done then
-		delete_hardbans()
+        Jane.bans_done = true
-		Jane.bans_done = true
+        delete_hardbans()
-	end
+    end
 
-	if (G.GAME or {}).banned_keys then
+    if (G.GAME or {}).banned_keys then
-		for _, v in pairs(Jane.config.bans) do
+        for _, v in pairs(Jane.config.bans) do
-			G.GAME.banned_keys[v] = true
+            G.GAME.banned_keys[v] = true
-		end
+        end
-	end
+    end
 
-	if G.ARGS.LOC_COLOURS then
+    if G.ARGS.LOC_COLOURS then
-		local r, g, b = hsv(self.C.jane_RGB_HUE / 360, .5, 1)
+        local r, g, b = hsv(self.C.jane_RGB_HUE / 360, .5, 1)
-		self.C.jane_RGB[1] = r
+        self.C.jane_RGB[1] = r
-		self.C.jane_RGB[3] = g
+        self.C.jane_RGB[3] = g
-		self.C.jane_RGB[2] = b
+        self.C.jane_RGB[2] = b
-		self.C.jane_RGB_HUE = (self.C.jane_RGB_HUE + 0.5) % 360
+        self.C.jane_RGB_HUE = (self.C.jane_RGB_HUE + 0.5) % 360
-		G.ARGS.LOC_COLOURS.jane_RGB = self.C.jane_RGB
+        G.ARGS.LOC_COLOURS.jane_RGB = self.C.jane_RGB
-	end
+    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 {
-	px = 34,
+    px = 34,
-	py = 34,
+    py = 34,
-	key = "modicon",
+    key = "modicon",
-	path = "almanac_avatar.png",
+    path = "almanac_avatar.png",
 }
 
 SMODS.Atlas {
-	px = 71,
+    px = 71,
-	py = 95,
+    py = 95,
-	key = "janeacc",
+    key = "janeacc",
-	path = Jane.config.texture_pack .. "/c_jane_acc.png",
+    path = Jane.config.texture_pack .. "/c_jane_acc.png",
 }
 
 for _, v in ipairs({
-	"back",
+    "back",
-	"blind",
+    "blind",
-	"booster",
+    "booster",
-	"edition",
+    "challenge",
-	"joker",
+    "edition",
-	"slugcat",
+    "joker",
-	"spectral",
+    "slugcat",
-	"tarot",
+    "spectral",
-	"token",
+    "tarot",
-	"voucher",
+    "token",
+    "voucher",
 }) do
-	assert(SMODS.load_file("src/" .. v .. ".lua"))()
+    assert(SMODS.load_file("src/" .. v .. ".lua"))()
 end

src/misprintize.lua

@@ -1,9 +1,8 @@
 -- The following code is slightly adapted from
 -- https://github.com/MathIsFun0/Cryptid/blob/main/lib/misprintize.lua
-
 local base_values = {}
 
-local big_num_whitelist = {
+local big_num_allowlist = {
     j_egg = true,
     j_wee = true,
     j_flash = true,
@@ -90,6 +89,11 @@ local function deep_copy(obj, seen)
     return res
 end
 
+local function format(number, str)
+    return math.abs(to_big(number)) >= to_big(1e300) and number
+        or tonumber(str:format((Big and to_number(to_big(number)) or number)))
+end
+
 local function is_card_big(joker)
     local center = joker.config and joker.config.center
 
@@ -97,24 +101,19 @@ local function is_card_big(joker)
         return false
     end
 
-    return big_num_whitelist[center.key or "Nope!"]
+    return big_num_allowlist[center.key or "Nope!"]
 end
 
 local function log_random(seed, min, max)
-	math.randomseed(seed)
+    math.randomseed(seed)
-	local lmin = math.log(min, 2.718281828459045)
+    local lmin = math.log(min, 2.718281828459045)
-	local lmax = math.log(max, 2.718281828459045)
+    local lmax = math.log(max, 2.718281828459045)
-	local poll = math.random() * (lmax - lmin) + lmin
+    local poll = math.random() * (lmax - lmin) + lmin
-	return math.exp(poll)
+    return math.exp(poll)
 end
 
 function Jane.misprintize_val(val, override, big)
-    local function format(number, str)
+    return is_number(val) and check(
-        return math.abs(to_big(number)) >= to_big(1e300) and number
-            or tonumber(str:format((Big and to_number(to_big(number)) or number)))
-    end
-
-	return is_number(val) and check(
         format(
             val * log_random(
                 pseudoseed("cry_misprint" .. G.GAME.round_resets.ante),
@@ -128,12 +127,12 @@ function Jane.misprintize_val(val, override, big)
 end
 
 function Jane.misprintize_tbl(name, ref_tbl, ref_value, clear, override, stack, big)
-	if name and ref_tbl and ref_value then
+    if name and ref_tbl and ref_value then
-		local tbl = deep_copy(ref_tbl[ref_value])
+        local tbl = deep_copy(ref_tbl[ref_value])
 
         for k, v in pairs(tbl) do
-			if (type(tbl[k]) ~= "table") or is_number(tbl[k]) then
+            if (type(tbl[k]) ~= "table") or is_number(tbl[k]) then
-				if is_number(tbl[k]) and not
+                if is_number(tbl[k]) and not
                     (k == "id") and not
                     (k == "colour") and not
                     (k == "suit_nominal") and not
@@ -142,170 +141,171 @@ function Jane.misprintize_tbl(name, ref_tbl, ref_value, clear, override, stack,
                     (k == "qty") and not
                     (k == "x_mult" and v == 1 and not tbl.override_x_mult_check) and not
                     (k == "selected_d6_face") then
-					if not base_values[name] then
+                    if not base_values[name] then
-						base_values[name] = {}
+                        base_values[name] = {}
-					end
+                    end
 
-					if not base_values[name][k] then
+                    if not base_values[name][k] then
-						base_values[name][k] = tbl[k]
+                        base_values[name][k] = tbl[k]
-					end
+                    end
 
                     tbl[k] = check(
-						clear and base_values[name][k]
+                        clear and base_values[name][k]
-							or cry_format(
+                        or format(
-								(stack and tbl[k] or base_values[name][k])
+                            (stack and tbl[k] or base_values[name][k])
-									* log_random(
+                            * log_random(
-										pseudoseed("cry_misprint" .. G.GAME.round_resets.ante),
+                                pseudoseed("cry_misprint" .. G.GAME.round_resets.ante),
-										override and override.min or G.GAME.modifiers.cry_misprint_min,
+                                override and override.min or G.GAME.modifiers.cry_misprint_min,
-										override and override.max or G.GAME.modifiers.cry_misprint_max
+                                override and override.max or G.GAME.modifiers.cry_misprint_max
-									),
+                            ),
-								"%.2g"
+                            "%.2g"
-							),
+                        ),
-						big
+                        big
-					)
+                    )
-				end
+                end
-			else
+            else
-				for _k, _ in pairs(tbl[k]) do
+                for _k, _ in pairs(tbl[k]) do
-					if is_number(tbl[k][_k]) and not
+                    if is_number(tbl[k][_k]) and not
-                    (_k == "id") and not
+                        (_k == "id") and not
-                    (k == "perish_tally") and not
+                        (k == "perish_tally") and not
-                    (k == "colour") and not
+                        (k == "colour") and not
-                    (_k == "suit_nominal") and not
+                        (_k == "suit_nominal") and not
-                    (_k == "base_nominal") and not
+                        (_k == "base_nominal") and not
-                    (_k == "face_nominal") and not
+                        (_k == "face_nominal") and not
-                    (_k == "qty") and not
+                        (_k == "qty") and not
-                    (k == "x_mult" and v == 1 and not tbl[k].override_x_mult_check) and not
+                        (k == "x_mult" and v == 1 and not tbl[k].override_x_mult_check) and not
-                    (_k == "selected_d6_face") then
+                        (_k == "selected_d6_face") then
-						if not base_values[name] then
+                        if not base_values[name] then
-							base_values[name] = {}
+                            base_values[name] = {}
-						end
+                        end
 
                         if not base_values[name][k] then
-							base_values[name][k] = {}
+                            base_values[name][k] = {}
-						end
+                        end
 
                         if not base_values[name][k][_k] then
-							base_values[name][k][_k] = tbl[k][_k]
+                            base_values[name][k][_k] = tbl[k][_k]
-						end
+                        end
 
-						tbl[k][_k] = check(
+                        tbl[k][_k] = check(
-							clear and base_values[name][k][_k]
+                            clear and base_values[name][k][_k]
-								or cry_format(
+                            or format(
-									(stack and tbl[k][_k] or base_values[name][k][_k]) *
+                                (stack and tbl[k][_k] or base_values[name][k][_k]) *
-                                        log_random(
+                                log_random(
-											pseudoseed("cry_misprint" .. G.GAME.round_resets.ante),
+                                    pseudoseed("cry_misprint" .. G.GAME.round_resets.ante),
-											override and override.min or G.GAME.modifiers.cry_misprint_min,
+                                    override and override.min or G.GAME.modifiers.cry_misprint_min,
-											override and override.max or G.GAME.modifiers.cry_misprint_max
+                                    override and override.max or G.GAME.modifiers.cry_misprint_max
-										),
+                                ),
-									"%.2g"
+                                "%.2g"
-								),
+                            ),
-							big
+                            big
-						)
+                        )
-					end
+                    end
-				end
+                end
-			end
+            end
-		end
+        end
 
-		ref_tbl[ref_value] = tbl
+        ref_tbl[ref_value] = tbl
-	end
+    end
 end
 
 function Jane.misprintize(card, override, force_reset, stack)
-	local function no(self, m, no_no)
+    local function no(self, m, no_no)
-		if no_no then
+        if no_no then
-			if self.infinifusion then
+            if self.infinifusion then
-				for i = 1, #self.infinifusion do
+                for i = 1, #self.infinifusion do
-					if G.P_CENTERS[self.infinifusion[i].key][m] or
+                    if G.P_CENTERS[self.infinifusion[i].key][m] or
-						(G.GAME and G.GAME[m] and G.GAME[m][self.infinifusion[i].key]) then
+                        (G.GAME and G.GAME[m] and G.GAME[m][self.infinifusion[i].key]) then
-						return true
+                        return true
-					end
+                    end
-				end
+                end
 
-				return false
+                return false
-			end
+            end
 
-			if not self.config then
+            if not self.config then
-				return G.P_CENTERS[self.key][m] or (G.GAME and G.GAME[m] and G.GAME[m][self.key])
+                return G.P_CENTERS[self.key][m] or (G.GAME and G.GAME[m] and G.GAME[m][self.key])
-			end
+            end
 
-			return self.config.center[m] or (G.GAME and G.GAME[m] and G.GAME[m][self.config.center_key]) or false
+            return self.config.center[m] or (G.GAME and G.GAME[m] and G.GAME[m][self.config.center_key]) or false
-		end
+        end
 
-		return no(self, "no_" .. m, true)
+        return no(self, "no_" .. m, true)
-	end
+    end
 
-	if no(card, "immutable", true) then
+    if no(card, "immutable", true) then
-		force_reset = true
+        force_reset = true
-	end
+    end
 
-	if card.infinifusion then
+    if card.infinifusion then
-		if card.config.center == card.infinifusion_center or card.config.center.key == "j_infus_fused" then
+        if card.config.center == card.infinifusion_center or card.config.center.key == "j_infus_fused" then
-			---@diagnostic disable-next-line: undefined-global
+            ---@diagnostic disable-next-line: undefined-global
-			calculate_infinifusion(card, nil, function(i)
+            calculate_infinifusion(card, nil, function(i)
-				Jane.misprintize(card, override, force_reset, stack)
+                Jane.misprintize(card, override, force_reset, stack)
-			end)
+            end)
-		end
+        end
-	end
+    end
-	if (not force_reset or G.GAME.modifiers.cry_jkr_misprint_mod) and
-		(G.GAME.modifiers.cry_misprint_min or override or card.ability.set == "Joker") and not
-		stack or not
-		no(card, "immutable", true)	then
-		if card.ability.name == "Ace Aequilibrium" then
-			return
-		end
 
-		if G.GAME.modifiers.cry_jkr_misprint_mod and card.ability.set == "Joker" then
+    if (not force_reset or G.GAME.modifiers.cry_jkr_misprint_mod) and
-			if not override then
+        (G.GAME.modifiers.cry_misprint_min or override or card.ability.set == "Joker") and not
-				override = {}
+        stack or not
-			end
+        no(card, "immutable", true) then
+        if card.ability.name == "Ace Aequilibrium" then
+            return
+        end
 
-			override.min = override.min or G.GAME.modifiers.cry_misprint_min or 1
+        if G.GAME.modifiers.cry_jkr_misprint_mod and card.ability.set == "Joker" then
-			override.max = override.max or G.GAME.modifiers.cry_misprint_max or 1
+            if not override then
-			override.min = override.min * G.GAME.modifiers.cry_jkr_misprint_mod
+                override = {}
-			override.max = override.max * G.GAME.modifiers.cry_jkr_misprint_mod
+            end
-		end
 
-		if G.GAME.modifiers.cry_misprint_min or override and override.min then
+            override.min = override.min or G.GAME.modifiers.cry_misprint_min or 1
-			Jane.misprintize_tbl(
+            override.max = override.max or G.GAME.modifiers.cry_misprint_max or 1
-				card.config.center_key,
+            override.min = override.min * G.GAME.modifiers.cry_jkr_misprint_mod
-				card,
+            override.max = override.max * G.GAME.modifiers.cry_jkr_misprint_mod
-				"ability",
+        end
-				nil,
-				override,
-				stack,
-				is_card_big(card)
-			)
 
-			if card.base then
+        if G.GAME.modifiers.cry_misprint_min or override and override.min then
-				Jane.misprintize_tbl(
+            Jane.misprintize_tbl(
-					card.config.card_key,
+                card.config.center_key,
-					card,
+                card,
-					"base",
+                "ability",
-					nil,
+                nil,
-					override,
+                override,
-					stack,
+                stack,
-					is_card_big(card)
+                is_card_big(card)
-				)
+            )
-			end
-		end
 
-		if G.GAME.modifiers.cry_misprint_min then
+            if card.base then
-			card.misprint_cost_fac = 1 /
+                Jane.misprintize_tbl(
+                    card.config.card_key,
+                    card,
+                    "base",
+                    nil,
+                    override,
+                    stack,
+                    is_card_big(card)
+                )
+            end
+        end
+
+        if G.GAME.modifiers.cry_misprint_min then
+            card.misprint_cost_fac = 1 /
                 log_random(
-					pseudoseed("cry_misprint" .. G.GAME.round_resets.ante),
+                    pseudoseed("cry_misprint" .. G.GAME.round_resets.ante),
-					override and override.min or G.GAME.modifiers.cry_misprint_min,
+                    override and override.min or G.GAME.modifiers.cry_misprint_min,
-					override and override.max or G.GAME.modifiers.cry_misprint_max
+                    override and override.max or G.GAME.modifiers.cry_misprint_max
-				)
+                )
 
-			card:set_cost()
+            card:set_cost()
-		end
+        end
-	else
+    else
-		Jane.misprintize_tbl(card.config.center_key, card, "ability", true, nil, nil, is_card_big(card))
+        Jane.misprintize_tbl(card.config.center_key, card, "ability", true, nil, nil, is_card_big(card))
-	end
+    end
 
-	if card.ability.consumeable then
+    if card.ability.consumeable then
-		for k, _ in pairs(card.ability.consumeable) do
+        for k, _ in pairs(card.ability.consumeable) do
-			card.ability.consumeable[k] = deep_copy(card.ability[k])
+            card.ability.consumeable[k] = deep_copy(card.ability[k])
-		end
+        end
-	end
+    end
 end

src/spectral.lua

@@ -1,354 +1,307 @@
 SMODS.Atlas {
-	key = "janertarots",
+    key = "janertarots",
-	px = 71,
+    px = 71,
-	py = 95,
+    py = 95,
-	path = Jane.config.texture_pack .. "/c_jane_reversetarots.png"
+    path = Jane.config.texture_pack .. "/c_jane_reversetarots.png",
 }
 
 SMODS.Sound({key = "draw", path = "draw.ogg"})
 
 local function conjure(card, number)
-	for _ = 1, math.min(
+    for _ = 1, math.min(
-		math.ceil(card.ability.extra.spectrals) * number,
+        math.ceil(card.ability.extra.spectrals) * number,
-		G.consumeables.config.card_limit - #G.consumeables.cards
+        G.consumeables.config.card_limit - #G.consumeables.cards
-	) do
+    ) 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
 end
 
-local function createfulldeck(enhancement, edition, amount, emplacement)
+local function create_full_deck(enhancement, edition, amount, emplacement)
-	local cards = {}
+    local cards = {}
 
-	for _, v in pairs(G.P_CARDS) do
+    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)
+        end
+    end
 
-					return true
+    Jane.q(function()
-				end
+        if next(cards) then
-			}))
+            playing_card_joker_effects(cards)
-		end
+        end
-	end
+    end)
-
-	Jane.q(function()
-		if next(cards) then
-			playing_card_joker_effects(cards)
-		end
-
-		return true
-	end)
-
-	Jane.q(function()
-		cards = nil
-		return true
-	end)
 end
 
 local function randomize(targets, noanim)
-	if #targets <= 0 then
+    if #targets <= 0 then
-		return
+        return
-	end
+    end
 
-	if noanim then
+    if noanim then
-		for i=1, #targets do
+        for i = 1, #targets do
-			local card = targets[i]
+            local card = targets[i]
-			card:set_base(pseudorandom_element(G.P_CARDS))
+            card:set_base(pseudorandom_element(G.P_CARDS))
 
-			card:set_ability(
+            card:set_ability(
-				pseudorandom(pseudoseed("chancetime")) > 1 / (#G.P_CENTER_POOLS["Enhanced"] + 1) and
+                pseudorandom(pseudoseed("chancetime")) > 1 / (#G.P_CENTER_POOLS["Enhanced"] + 1) and
-				pseudorandom_element(G.P_CENTER_POOLS["Enhanced"], pseudoseed("spectral_chance")) or
+                pseudorandom_element(G.P_CENTER_POOLS["Enhanced"], pseudoseed("spectral_chance")) or
-				G.P_CENTERS["c_base"]
+                G.P_CENTERS["c_base"]
-			)
+            )
 
-			local edition_rate = 2
+            local edition_rate = 2
-			card:set_edition(poll_edition("standard_edition" .. G.GAME.round_resets.ante, edition_rate, true), true, true)
+            card:set_edition(poll_edition("standard_edition" .. G.GAME.round_resets.ante, edition_rate, true), true, 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
+                end
 
-				seal_type = math.floor(seal_type * #seal_list)
+                seal_type = math.floor(seal_type * #seal_list)
-				card:set_seal(seal_list[seal_type], true, true)
+                card:set_seal(seal_list[seal_type], true, true)
-			else
+            else
-				card:set_seal(nil, true, true)
+                card:set_seal(nil, true, true)
-			end
+            end
 
-			card:juice_up(0.3, 0.3)
+            card:juice_up(0.3, 0.3)
-		end
+        end
-	else
+    else
-		for i = 1, #targets do
+        for i = 1, #targets do
-			local percent = 1.15 - (i - 0.999) / (#G.hand.cards - 0.998) * 0.3
+            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)
+        end
-					targets[i]:juice_up(0.3, 0.3)
-					return true
-				end
-			}))
-		end
 
-		delay(0.2)
+        delay(0.2)
 
-		for i = 1, #targets do
+        for i = 1, #targets do
-			local percent = 0.85 + (i - 0.999) / (#G.hand.cards - 0.998) * 0.3
+            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
+                    end
 
-						seal_type = math.floor(seal_type * #seal_list)
+                    seal_type = math.floor(seal_type * #seal_list)
-						card:set_seal(seal_list[seal_type])
+                    card:set_seal(seal_list[seal_type])
-					else
+                else
-						card:set_seal()
+                    card:set_seal()
-					end
+                end
 
-					card:flip()
+                card:flip()
-					play_sound("card3", percent, 0.6)
+                play_sound("card3", percent, 0.6)
-					card:juice_up(0.3, 0.3)
+                card:juice_up(0.3, 0.3)
-					return true
+            end, 0.1)
-				end
+        end
-			}))
+    end
-		end
-	end
 end
 
 SMODS.Consumable {
-	key = "obfuscation",
+    key = "obfuscation",
-	atlas = "janeacc",
+    atlas = "janeacc",
-	set = "Spectral",
+    set = "Spectral",
-	loc_txt = {
+    loc_txt = {
-		name = "Obfuscation",
+        name = "Obfuscation",
-		text = {
+        text = {
-			"{C:green,E:1}Randomises{} all cards in hand",
+            "{C:green,E:1}Randomises{} all cards in hand",
-			"{C:inactive}(Rank, seal, edition,",
+            "{C:inactive}(Rank, seal, edition,",
-			"{C:inactive}enhancement, and suit)",
+            "{C:inactive}enhancement, and suit)",
-		}
+        },
-	},
+    },
-	pos = {x = 0, y = 4},
+    pos = {x = 0, y = 4},
-	cost = 4,
+    cost = 4,
-	can_use = function(_, _)
+    can_use = function(_, _)
-		return Jane.canuse() and #((G.hand or {}).cards or {}) > 0
+        return Jane.can_use() and #((G.hand or {}).cards or {}) > 0
-	end,
+    end,
-	use = function(_, card, _, _)
+    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)
+        randomize(G.hand.cards)
-		delay(0.5)
+        delay(0.5)
-	end
+    end,
 }
 
 SMODS.Consumable {
-	key = "conjure",
+    key = "conjure",
-	set = "Spectral",
+    set = "Spectral",
-	atlas = "janeacc",
+    atlas = "janeacc",
-	loc_txt = {
+    loc_txt = {
-		name = "Conjure",
+        name = "Conjure",
-		text = {
+        text = {
-			"Creates {C:attention}#1#",
+            "Creates {C:attention}#1#",
-			"{C:spectral}Spectral{} cards",
+            "{C:spectral}Spectral {}cards",
-			"{C:inactive}(Must have room)",
+            "{C:inactive}(Must have room)",
-		}
+        },
-	},
+    },
-	config = {extra = {spectrals = 2}},
+    config = {extra = {spectrals = 2}},
-	pos = {x = 2, y = 4},
+    pos = {x = 2, y = 4},
-	cost = 4,
+    cost = 4,
-    loc_vars = function(self, info_queue, center)
+    loc_vars = function(_, _, center)
         return {vars = {math.ceil(center.ability.extra.spectrals)}}
     end,
-	can_use = Jane.canuse,
+    can_use = Jane.can_use,
-	use = function(_, card, _, _)
+    use = function(_, card, _, _)
-		conjure(card, 1)
+        conjure(card, 1)
-		delay(0.6)
+        delay(0.6)
-	end,
+    end,
-	bulk_use = function(_, card, _, _, number)
+    bulk_use = function(_, card, _, _, number)
-		conjure(card, number)
+        conjure(card, number)
-		delay(0.6)
+        delay(0.6)
-	end
+    end,
+}
+
+local shadows_limit = 25
+
+SMODS.Consumable {
+    key = "shadows",
+    set = "Spectral",
+    atlas = "janeacc",
+    loc_txt = {
+        name = "Shadows",
+        text = {
+            "Create {C:attention}#1#{} {C:green}random {C:dark_edition}Negative",
+            "{C:attention}Perishable {C:attention}Jokers{}, set {C:money}sell",
+            "{C:money}value {}of {C:attention}all Jokers {}to {C:money}$0",
+        },
+    },
+    config = {extra = {shadows = 2}},
+    pos = {x = 3, y = 4},
+    cost = 4,
+    loc_vars = function(_, _, card)
+        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, 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
+            joker.ability.perishable = true
+            joker.ability.perish_tally = 5
+            joker:add_to_deck()
+            G.jokers:emplace(joker)
+        end
+
+        delay(0.6)
+
+        for i = 1, #G.jokers.cards do
+            G.jokers.cards[i].base_cost = 0
+            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
+        end
+    end,
+    bulk_use = function(_, card, _, _, number)
+        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})
+            joker.no_forced_edition = nil
+            joker.ability.eternal = false
+            joker.ability.perishable = true
+            joker.ability.perish_tally = 5
+            joker:add_to_deck()
+            G.jokers:emplace(joker)
+        end
+
+        delay(0.6)
+
+        for i = 1, #G.jokers.cards do
+            G.jokers.cards[i].base_cost = 0
+            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
+        end
+    end,
 }
 
 SMODS.Consumable {
-	key = "shadows",
+    key = "rift",
-	set = "Spectral",
+    atlas = "janeacc",
-	atlas = "janeacc",
+    set = "Spectral",
-	loc_txt = {
+    loc_txt = {
-		name = "Shadows",
+        name = "Rift",
-		text = {
+        text = {
-			"Create {C:attention}#1#{} {C:green}random {C:dark_edition}Negative",
+            "{C:attention}Reset {}your deck to a",
-			"{C:attention}Perishable {C:attention}Jokers{}, set",
+            "{C:attention}standard 52-card deck",
-			"{C:money}sell value{} of {C:attention}all Jokers{} to {C:money}$0",
+        },
-		}
+    },
-	},
+    pos = {x = 4, y = 4},
-	config = {extra = {shadows = 2}},
+    cost = 4,
-	pos = {x = 3, y = 4},
+    can_use = Jane.can_use,
-	cost = 4,
+    use = function(_, _, _, _)
-    loc_vars = function(_, _, center)
+        Jane.q(function()
-        return {vars = {((center.ability or {}).extra or {}).shadows or 2}}
+            for _, v in pairs(G.playing_cards) do
+                v:start_dissolve()
+            end
+        end)
+
+        delay(2)
+        create_full_deck()
     end,
-	can_use = Jane.canuse,
-	use = function(_, card, _, _)
-		for _ = 1, card.ability.extra.shadows do
-			local joker = create_card("Joker", G.jokers, nil, nil, nil, nil, nil, "phantom")
-			joker:set_edition({negative = true})
-			joker.ability.eternal = false
-			joker.ability.perishable = true
-			joker.ability.perish_tally = 5
-			joker:add_to_deck()
-			G.jokers:emplace(joker)
-		end
-
-		delay(0.6)
-
-		for i = 1, #G.jokers.cards do
-			G.jokers.cards[i].base_cost = 0
-			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
-		end
-	end,
-	bulk_use = function(_, card, _, _, number)
-		for _ = 1, card.ability.extra.shadows * 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})
-			joker.no_forced_edition = nil
-			joker.ability.eternal = false
-			joker.ability.perishable = true
-			joker.ability.perish_tally = 5
-			joker:add_to_deck()
-			G.jokers:emplace(joker)
-		end
-
-		delay(0.6)
-
-		for i = 1, #G.jokers.cards do
-			G.jokers.cards[i].base_cost = 0
-			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
-		end
-	end
-}
-
-
-SMODS.Consumable {
-	key = "reverse_hanged_man",
-	atlas = "janertarots",
-	set = "Spectral",
-	loc_txt = {
-		name = "Zen",
-		text = {
-			"{C:attention}Reset{} your deck to",
-			"a {C:attention}standard 52-card deck"
-		}
-	},
-	config = {extra = {destruction = 0.5}},
-	pos = {x = 7, y = 1},
-	cost = 15,
-    loc_vars = function(_, _, center)
-        return {vars = {
-			math.min(100, center.ability.extra.destruction * 100),
-			math.ceil(#(G.playing_cards or {}) * center.ability.extra.destruction)
-		}}
-    end,
-	can_use = Jane.canuse,
-	use = function(_, _, _, _)
-		Jane.q(function()
-			for _, v in pairs(G.playing_cards) do
-				v:start_dissolve()
-			end
-
-			return true
-		end)
-
-		local function realdelay(time, queue)
-			G.E_MANAGER:add_event(Event({
-				trigger = "after",
-				timer = "REAL",
-				delay = time or 1,
-				func = function()
-				   return true
-				end
-			}), queue)
-		end
-
-		realdelay(1)
-		createfulldeck()
-	end
 }

src/tarot.lua

@@ -1,51 +1,82 @@
+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 = {
-	"Hey! Pick me!",
+    "M!",
-	"You wouldn't say no to a free negative me, would you?",
+    "Hey! Pick me!",
-	"Sometimes, an extra four mult goes a long way!",
+    "Hee-hee, hoo-hoo!",
-	"I won't take up space, I promise!",
+    "Looks like the joke is on you!",
-	"Don't ask how I ended up in a tarot!",
+    "Ouch, I think the joke is on me!",
-	"Hee-hee, hoo-hoo!",
+    "I won't take up space, I promise!",
-	"Who knew even fortunes could be a circus act?",
+    "Don't ask how I ended up in a tarot!",
-	"Looks like the joke is on the crystal globe!",
+    "The stakes are only gonna rise here!",
-	"It's a little cramped in this tarot...!",
+    "I wonder what's the deal with pairs?",
-	"Ouch, I think the joke is on me!",
+    "It's a little cramped in this tarot...!",
-	"Looks like the joke is on you!",
+    "Juggling is one of my favourite passtimes!",
-	"I'm not just a clown; I'm the whole circus!",
+    "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...",
+    "Looks like the joke is on the crystal globe!",
-	"I can't help if I'm still in this silly old card, break me out!",
+    "Who knew even fortunes could be a circus act?",
-	"Let me tell you, you'd love the show going on in this tarot!",
+    "Sometimes, an extra four mult goes a long way!",
-	"I'd give you more tickets to JimCon, but I'm fresh out.",
+    "I can't give four mult if I'm still in this card!",
-	"I've heard of a round buffoon that lives in a pretty funky town...",
+    "You wouldn't say no to a free negative me, would you?",
-	"I can't give four mult if I'm still in this card!",
+    "I'd give you more tickets to JimCon, but I'm fresh out.",
-	"I'm rooting for you! Even if it means I'll never get out of this card...",
+    "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!",
+    "Who knew I'd have access to a great show? That show being you!",
-	"The stakes are only gonna rise here!",
+    "I can't help if I'm still in this silly old card, break me out!",
-	"Juggling is one of my favourite passtimes!",
+    "I've heard of a round buffoon that lives in a pretty funky town...",
-	"I wonder what's the deal with pairs?",
+    "You don't need to understand math to enjoy watching the digits climb!",
-	"You don't need to understand math to enjoy watching the digits climb!",
+    "I'm rooting for you! Even if it means I'll never get out of this card...",
-	"You should meet my friend Joseph; he's stuck in a Planet card!",
+    "Seems a little suspicious for a jolly old fella like me to be in this card...",
-	"M!",
 }
 
 SMODS.Consumable {
-	key = "jokerinatarot",
+    key = "jokerinatarot",
-	atlas = "janeacc",
+    atlas = "janeacc",
-	set = "Tarot",
+    set = "Tarot",
-	loc_txt = {
+    loc_txt = {
-		name = "Joker-in-a-Tarot",
+        name = "#1#-in-a-Tarot",
-		text = {
+        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(_, _, _)
+    },
-        return {vars = {blurbs[math.random(#blurbs)]}}
+    loc_vars = function(_, info_queue, card)
+        info_queue[#info_queue + 1] = G.P_CENTERS[j()]
+        local is_jolly = G.GAME.used_vouchers.v_jane_jolly_voucher
+
+        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},
+    pos = {x = 0, y = 1},
-	cost = 3,
+    cost = 4,
-	can_use = Jane.canuse,
+    can_use = Jane.can_use,
-	use = function(_, _, _, _)
+    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
@@ -54,10 +85,17 @@ SMODS.Consumable {
         card.sell_cost_label = card.facing == "back" and "?" or card.sell_cost
         card:add_to_deck()
         G.jokers:emplace(card)
-	end,
+    end,
-	bulk_use = function(self, card, area, copier, number)
+    bulk_use = function(self, card, area, copier, number)
-		for _ = 1, number do
+        for _ = 1, number do
             self:use(card, area, copier)
-		end
+        end
-	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

@@ -1,86 +1,127 @@
 SMODS.Atlas {
-	key = "janetokens",
+    key = "janetokens",
-	px = 71,
+    px = 71,
-	py = 95,
+    py = 95,
-	path = Jane.config.texture_pack .. "/c_jane_tokens.png"
+    path = Jane.config.texture_pack .. "/c_jane_tokens.png",
 }
 
 SMODS.Sound({key = "e_gilded", path = "e_gilded.ogg"})
 
 SMODS.ConsumableType {
-	key = "jane_tokens",
+    key = "jane_tokens",
-	default = "c_jane_token_tag_standard",
+    default = "c_jane_token_tag_standard",
-	loc_txt = {
+    loc_txt = {
-		collection = "Tokens",
+        collection = "Tokens",
-		name = "Token"
+        name = "Token",
-	},
+    },
-	shop_rate = 0,
+    shop_rate = 0,
-	collection_rows = {6, 6},
+    collection_rows = {5, 6},
-	primary_colour = G.C.CHIPS,
+    primary_colour = G.C.CHIPS,
-	secondary_colour = G.C.VOUCHER,
+    secondary_colour = G.C.VOUCHER,
 }
 
-for _, v in pairs({
+local function on_token_use(id)
-	{"tag_standard", "Standard", 0, 0, 3},
+    local t = Tag(id)
-	{"tag_charm", "Charm", 1, 0, 5},
-	{"tag_meteor", "Meteor", 2, 0, 5},
-	{"tag_ethereal", "Ethereal", 3, 0, 5},
-	{"tag_buffoon", "Buffoon", 4, 0, 8},
-	{"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_foil", "Foil", 1, 3, 3},
-	{"tag_holo", "Holographic", 2, 3, 4},
-	{"tag_polychrome", "Polychrome", 3, 3, 5},
-	{"tag_negative", "Negative", 4, 3, 10},
-	{"tag_investment", "Investment", 0, 3, 8},
-	{"tag_voucher", "Voucher", 4, 5, 5},
-	{"tag_handy", "Handy", 1, 5, 8},
-	{"tag_garbage", "Garbage", 0, 5, 6},
-	{"tag_coupon", "Coupon", 4, 4, 10},
-	{"tag_juggle", "Juggle", 2, 5, 2},
-	{"tag_d_six", "Dice", 0, 4, 2},
-	{"tag_top_up", "Top-up", 2, 4, 2},
-	{"tag_skip", "Speed", 4, 2, 7},
-	{"tag_economy", "Economy", 5, 2, 10},
-	{"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_cry_memory", "Memory", 5, 4, 8}
-}) do
-	if Cryptid or v[1]:sub(1, 7) ~= "tag_cry" then
-		SMODS.Consumable {
-			key = "token_" .. v[1],
-			set = "jane_tokens",
-			atlas = "janetokens",
-			loc_txt = {
-				name = v[2] .. " Token",
-				text = {
-					"Use to create a",
-					"{C:attention}" .. v[2] .. " Tag",
-				},
-			},
-			pos = {x = v[3], y = v[4]},
-			cost = v[5],
-			can_stack = true,
-			can_divide = true,
-			can_use = Jane.canuse,
-			in_pool = function (_, _)
-				return G.GAME.used_vouchers.v_jane_token_voucher
-			end,
-			use = function(_, _, _, _)
-				play_sound("jane_e_gilded", 1.25, 0.4)
-				add_tag(Tag(v[1]))
-			end,
-			bulk_use = function(_, _, _, _, number)
-				play_sound("jane_e_gilded", 1.25, 0.4)
 
-				for _ = 1, number do
+    if id == "tag_orbital" then
-					add_tag(Tag(v[1]))
+        local hands = {}
-				end
+
-			end
+        for k, v in pairs(G.GAME.hands) do
-		}
+            if v.visible then
-	end
+                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},
+    {"tag_meteor",             "Meteor",        2, 0, 5},
+    {"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_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_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 {
+            key = "token_" .. v[1],
+            set = "jane_tokens",
+            atlas = "janetokens",
+            loc_txt = {
+                name = v[2] .. " Token",
+                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] = v[1] ~= "tag_cry_cat" and G.P_TAGS[v[1]] or nil
+                return {vars = {}}
+            end,
+            pos = {x = v[3], y = v[4]},
+            cost = v[5],
+            can_stack = true,
+            can_divide = true,
+            can_use = Jane.can_use,
+            in_pool = function(_, _)
+                return G.GAME.used_vouchers.v_jane_token_voucher
+            end,
+            use = function(_, _, _, _)
+                play_sound("jane_e_gilded", 1.25, 0.4)
+                on_token_use(v[1])
+            end,
+            bulk_use = function(_, _, _, _, number)
+                play_sound("jane_e_gilded", 1.25, 0.4)
+
+                for _ = 1, number do
+                    on_token_use(v[1])
+                end
+            end,
+        }
+    end
 end

src/voucher.lua

@@ -1,23 +1,43 @@
 SMODS.Atlas {
-	key = "janetokenvoucher",
+    key = "janejollyvoucher",
-	px = 71,
+    px = 71,
-	py = 95,
+    py = 95,
-	path = Jane.config.texture_pack .. "/v_jane_token_voucher.png"
+    path = Jane.config.texture_pack .. "/v_jane_jolly_voucher.png",
+}
+
+SMODS.Atlas {
+    key = "janetokenvoucher",
+    px = 71,
+    py = 95,
+    path = Jane.config.texture_pack .. "/v_jane_token_voucher.png",
 }
 
 SMODS.Voucher {
-	key = "token_voucher",
+    key = "jolly_voucher",
-	atlas = "janetokenvoucher",
+    atlas = "janejollyvoucher",
-	loc_txt = {
+    loc_txt = {
-		name = "Token Voucher",
+        name = "Jolly Voucher",
-		text = {
+        text = {"{C:attention,T:c_jane_jokerinatarot}Joker-in-a-Tarot {}creates", "{C:attention,T:j_jolly}Jolly Joker {}instead"},
-			"{C:attention}Tokens {}can appear",
+    },
-			"in the shop",
+    pos = {x = 0, y = 0},
-		}
+    cost = 8,
-	},
+    loc_vars = function(_, info_queue, _)
-	pos = {x = 0, y = 0},
+        info_queue[#info_queue + 1] = G.P_CENTERS.c_jane_jokerinatarot
-	cost = 15,
+        info_queue[#info_queue + 1] = G.P_CENTERS.j_jolly
-	redeem = function (_, _)
+        return {vars = {}}
-		G.GAME['jane_tokens_rate'] = 1.5
+    end,
-	end
+}
+
+SMODS.Voucher {
+    key = "token_voucher",
+    atlas = "janetokenvoucher",
+    loc_txt = {
+        name = "Token Voucher",
+        text = {"{C:attention}Tokens {}can appear", "in the shop"},
+    },
+    pos = {x = 0, y = 0},
+    cost = 15,
+    redeem = function(_, _)
+        G.GAME["jane_tokens_rate"] = 1.5
+    end,
 }