Remove unplayable garbage

localization/en-us.lua

@@ -415,7 +415,6 @@ return {
             c_Roland_Jokerful = "Jokerful",
             c_Roland_Ornate = "Ornate",
             c_Roland_Pastries = "Sweet Pastries",
-            c_Roland_Showdown = "Showdown",
             c_Roland_Spin_To_Win = "Spin to Win",
         },
         v_dictionary = {
@@ -454,7 +453,6 @@ return {
             ch_c_Roland_Jokerful = {"The only jokers are {C:mult}Joker{} and {C:chips}Ms. Joker"},
             ch_c_Roland_Ornate = {"Anything vanilla is banned"},
             ch_c_Roland_Pastries = {"All blinds, cards, and tags are of {C:gold}Bakery{} or {C:blue}Roland"},
-            ch_c_Roland_Showdown = {"Showdown blinds are {C:attention}Venerable Visage"},
             ch_c_Roland_Showdown_Amber = {"Showdown blinds are {C:attention}Amber Acorn {}(stacks with above)"},
             ch_c_Roland_Showdown_Cerulean = {"Showdown blinds are {C:attention}Cerulean Bell {}(stacks with above)"},
             ch_c_Roland_Showdown_Crimson = {"Showdown blinds are {C:attention}Crimson Heart {}(stacks with above)"},

manifest.json

@@ -6,12 +6,12 @@
     "author": [
         "Emik"
     ],
-    "version": "2.6.5",
+    "version": "2.6.6",
     "badge_colour": "8BE9FD",
     "main_file": "src/main.lua",
     "badge_text_colour": "44475A",
     "display_name": "Roland",
-    "description": "Adds several disconnected funny ideas I had in my head that I couldn't resist implementing in the game.",
+    "description": "Adds mechanics that are meant to have interesting interactions with the base game. Not meant to be balanced, but not entirely broken either.",
     "provides": [],
     "conflicts": [],
     "dependencies": [

src/challenge.lua

@@ -45,8 +45,8 @@ local function is_vanilla(v)
     end)
 end
 
-local vanillas, pastries, amber, cerulean, crimson, verdant, violet, final
+local vanillas, pastries, amber, cerulean, crimson, verdant, violet
-= bans(), bans(), bans(), bans(), bans(), bans(), bans(), bans()
+= bans(), bans(), bans(), bans(), bans(), bans(), bans()
 
 SMODS.Challenge {
     key = "Go",
@@ -104,194 +104,177 @@ SMODS.Challenge {
     pronouns = "she_them",
 }
 
-local finalizers = {
+SMODS.Challenge {
-    SMODS.Challenge {
+    key = "Eternally_Amber",
-        key = "Eternally_Amber",
+    rules = {custom = {{id = "Roland_Eternally_Amber"}, {id = "Roland_Showdown_Amber"}}},
-        rules = {custom = {{id = "Roland_Eternally_Amber"}, {id = "Roland_Showdown_Amber"}}},
+    restrictions = amber,
-        restrictions = amber,
+    calculate = function(_, context)
-        calculate = function(_, context)
+        local function slide(pitch)
-            local function slide(pitch)
+            q(function()
-                q(function()
+                G.jokers:shuffle "Roland_aajk"
-                    G.jokers:shuffle "Roland_aajk"
+                play_sound("cardSlide1", pitch)
-                    play_sound("cardSlide1", pitch)
-                end)
-            end
-
-            if not context.setting_blind then
-                return
-            end
-
-            G.jokers:unhighlight_all()
-
-            f(G.jokers.cards):each(function(v)
-                v:flip()
             end)
+        end
 
-            local _ = #G.jokers.cards > 1 and q {
+        if not context.setting_blind then
-                trigger = "after",
+            return
-                delay = 0.2,
+        end
-                func = function()
-                    slide(0.85)
-                    delay(0.15)
-                    slide(1.15)
-                    delay(0.15)
-                    slide(1)
-                    delay(0.5)
-                end,
-            }
-        end,
-    },
-    SMODS.Challenge {
-        key = "Eternally_Cerulean",
-        rules = {custom = {{id = "Roland_Eternally_Cerulean"}, {id = "Roland_Showdown_Cerulean"}}},
-        restrictions = cerulean,
-        calculate = function(_, context)
-            if not context.hand_drawn then
-                return
-            end
 
-            ---@type SMODS.Blind|{name: string}
+        G.jokers:unhighlight_all()
-            local blind = G.GAME.blind
-            local copy = f(G.hand.cards):table()
-            pseudoshuffle(copy, pseudoseed "Roland_cerulean_bell")
-            G.hand:unhighlight_all()
 
-            local count = (blind.name == "Cerulean Bell" and 2 or 1) -
+        f(G.jokers.cards):each(function(v)
-                f(G.hand.cards):map "ability":count "forced_selection"
+            v:flip()
+        end)
 
-            f(copy):take(count):each(function(v)
+        local _ = #G.jokers.cards > 1 and q {
-                v.ability.forced_selection = true
+            trigger = "after",
-                G.hand:add_to_highlighted(v)
+            delay = 0.2,
-            end)
+            func = function()
-        end,
+                slide(0.85)
-    },
+                delay(0.15)
-    SMODS.Challenge {
+                slide(1.15)
-        key = "Eternally_Crimson",
+                delay(0.15)
-        rules = {custom = {{id = "Roland_Eternally_Crimson"}, {id = "Roland_Showdown_Crimson"}}},
+                slide(1)
-        restrictions = crimson,
+                delay(0.5)
-        calculate = function(_, context)
+            end,
-            local _ = context.blind_defeated and f(G.jokers.cards):each(function(v)
+        }
-                v.ability.Roland_crimson_heart_chosen = nil
+    end,
-            end)
-
-            local mod = G.GAME.modifiers
-            mod.Roland_Eternally_Crimson = not context.setting_blind and mod.Roland_Eternally_Crimson or nil
-            local debuff = context.debuff_card
-            ---@type (SMODS.Joker|{ability?: {Roland_crimson_heart_chosen: boolean?}, debuff: boolean?})[]
-            local cards = G.jokers.cards
-
-            if debuff and
-                debuff.ability and
-                debuff.area == G.jokers and
-                debuff.ability.Roland_crimson_heart_chosen then
-                return {debuff = true}
-            end
-
-            if context.press_play and next(cards) then
-                mod.Roland_Eternally_Crimson = true
-            end
-
-            if context.hand_drawn and
-                mod.Roland_Eternally_Crimson and
-                next(cards) then
-                local prev = {}
-                local jokers = {}
-
-                f(cards):where(function(v)
-                    return (v.ability or {}).Roland_crimson_heart_chosen
-                end):each(function(v)
-                    prev[v] = true
-                    v.ability.Roland_crimson_heart_chosen = nil
-                    local _ = v.debuff and SMODS.recalc_debuff(v)
-                end)
-
-                jokers = next(jokers) and jokers or f(cards):where("debuff", false):map(function(v)
-                    local _ = not prev[v] and table.insert(jokers, v)
-                    return v
-                end):table()
-
-                local card = pseudorandom_element(jokers, pseudoseed "Roland_crimson_heart")
-
-                if card then
-                    card.ability.Roland_crimson_heart_chosen = true
-                    SMODS.recalc_debuff(card)
-                    card:juice_up()
-                end
-            end
-
-            mod.Roland_Eternally_Crimson = not context.hand_drawn and
-                mod.Roland_Eternally_Crimson or nil
-        end,
-    },
-    SMODS.Challenge {
-        key = "Eternally_Verdant",
-        rules = {custom = {{id = "Roland_Eternally_Verdant"}, {id = "Roland_Showdown_Verdant"}}},
-        restrictions = verdant,
-        calculate = function(_, context)
-            if context.setting_blind then
-                G.GAME.modifiers.Roland_Eternally_Verdant = true
-            end
-
-            if context.debuff_card and context.debuff_card.area ~= G.jokers then
-                return {debuff = G.GAME.modifiers.Roland_Eternally_Verdant}
-            end
-
-            if context.selling_card and context.card.ability.set == "Joker" then
-                q(function()
-                    G.GAME.modifiers.Roland_Eternally_Verdant = nil
-                end)
-            end
-        end,
-    },
-    SMODS.Challenge {
-        key = "Eternally_Violet",
-        rules = {custom = {{id = "Roland_Eternally_Violet"}, {id = "Roland_Showdown_Violet"}}},
-        restrictions = violet,
-        calculate = function(_, context)
-            if context.setting_blind then
-                G.GAME.blind.chips = G.GAME.blind.chips * 6
-                G.GAME.blind.chip_text = number_format(G.GAME.blind.chips)
-            end
-        end,
-    },
 }
 
 SMODS.Challenge {
-    key = "Showdown",
+    key = "Eternally_Cerulean",
-    rules = {custom = {
+    rules = {custom = {{id = "Roland_Eternally_Cerulean"}, {id = "Roland_Showdown_Cerulean"}}},
-        {id = "Roland_Eternally_Amber"},
+    restrictions = cerulean,
-        {id = "Roland_Eternally_Cerulean"},
-        {id = "Roland_Eternally_Crimson"},
-        {id = "Roland_Eternally_Verdant"},
-        {id = "Roland_Eternally_Violet"},
-        {id = "Roland_Showdown"},
-    }},
-    restrictions = final,
     calculate = function(_, context)
-        f(finalizers):each(function(v)
+        if not context.hand_drawn then
-            v:calculate(context)
+            return
+        end
+
+        ---@type SMODS.Blind|{name: string}
+        local blind = G.GAME.blind
+        local copy = f(G.hand.cards):table()
+        pseudoshuffle(copy, pseudoseed "Roland_cerulean_bell")
+        G.hand:unhighlight_all()
+
+        local count = (blind.name == "Cerulean Bell" and 2 or 1) -
+            f(G.hand.cards):map "ability":count "forced_selection"
+
+        f(copy):take(count):each(function(v)
+            v.ability.forced_selection = true
+            G.hand:add_to_highlighted(v)
         end)
     end,
 }
 
+SMODS.Challenge {
+    key = "Eternally_Crimson",
+    rules = {custom = {{id = "Roland_Eternally_Crimson"}, {id = "Roland_Showdown_Crimson"}}},
+    restrictions = crimson,
+    calculate = function(_, context)
+        local _ = context.blind_defeated and f(G.jokers.cards):each(function(v)
+            v.ability.Roland_crimson_heart_chosen = nil
+        end)
+
+        local mod = G.GAME.modifiers
+        mod.Roland_Eternally_Crimson = not context.setting_blind and mod.Roland_Eternally_Crimson or nil
+        local debuff = context.debuff_card
+        ---@type (SMODS.Joker|{ability?: {Roland_crimson_heart_chosen: boolean?}, debuff: boolean?})[]
+        local cards = G.jokers.cards
+
+        if debuff and
+            debuff.ability and
+            debuff.area == G.jokers and
+            debuff.ability.Roland_crimson_heart_chosen then
+            return {debuff = true}
+        end
+
+        if context.press_play and next(cards) then
+            mod.Roland_Eternally_Crimson = true
+        end
+
+        if context.hand_drawn and
+            mod.Roland_Eternally_Crimson and
+            next(cards) then
+            local prev = {}
+            local jokers = {}
+
+            f(cards):where(function(v)
+                return (v.ability or {}).Roland_crimson_heart_chosen
+            end):each(function(v)
+                prev[v] = true
+                v.ability.Roland_crimson_heart_chosen = nil
+                local _ = v.debuff and SMODS.recalc_debuff(v)
+            end)
+
+            jokers = next(jokers) and jokers or f(cards):where("debuff", false):map(function(v)
+                local _ = not prev[v] and table.insert(jokers, v)
+                return v
+            end):table()
+
+            local card = pseudorandom_element(jokers, pseudoseed "Roland_crimson_heart")
+
+            if card then
+                card.ability.Roland_crimson_heart_chosen = true
+                SMODS.recalc_debuff(card)
+                card:juice_up()
+            end
+        end
+
+        mod.Roland_Eternally_Crimson = not context.hand_drawn and
+            mod.Roland_Eternally_Crimson or nil
+    end,
+}
+
+SMODS.Challenge {
+    key = "Eternally_Verdant",
+    rules = {custom = {{id = "Roland_Eternally_Verdant"}, {id = "Roland_Showdown_Verdant"}}},
+    restrictions = verdant,
+    calculate = function(_, context)
+        if context.setting_blind then
+            G.GAME.modifiers.Roland_Eternally_Verdant = true
+        end
+
+        if context.debuff_card and context.debuff_card.area ~= G.jokers then
+            return {debuff = G.GAME.modifiers.Roland_Eternally_Verdant}
+        end
+
+        if context.selling_card and context.card.ability.set == "Joker" then
+            q(function()
+                G.GAME.modifiers.Roland_Eternally_Verdant = nil
+            end)
+        end
+    end,
+}
+
+SMODS.Challenge {
+    key = "Eternally_Violet",
+    rules = {custom = {{id = "Roland_Eternally_Violet"}, {id = "Roland_Showdown_Violet"}}},
+    restrictions = violet,
+    calculate = function(_, context)
+        if context.setting_blind then
+            G.GAME.blind.chips = G.GAME.blind.chips * 6
+            G.GAME.blind.chip_text = number_format(G.GAME.blind.chips)
+        end
+    end,
+}
+
 q(function()
     if not G.P_CENTERS.j_Bakery_Spinner then
         spin_to_win.jokers = nil
     end
 
     f {
-        {G.P_TAGS,    is_vanilla,                                      vanillas.banned_tags},
+        {G.P_TAGS,    is_vanilla,                           vanillas.banned_tags},
-        {G.P_BLINDS,  is_vanilla,                                      vanillas.banned_other},
+        {G.P_BLINDS,  is_vanilla,                           vanillas.banned_other},
-        {G.P_CENTERS, is_vanilla,                                      vanillas.banned_cards},
+        {G.P_CENTERS, is_vanilla,                           vanillas.banned_cards},
-        {G.P_TAGS,    is_banned_from_pastry,                           pastries.banned_tags},
+        {G.P_TAGS,    is_banned_from_pastry,                pastries.banned_tags},
-        {G.P_BLINDS,  is_banned_from_pastry,                           pastries.banned_other},
+        {G.P_BLINDS,  is_banned_from_pastry,                pastries.banned_other},
-        {G.P_CENTERS, is_center_banned_from_pastry,                    pastries.banned_cards},
+        {G.P_CENTERS, is_center_banned_from_pastry,         pastries.banned_cards},
-        {G.P_BLINDS,  is_showdown_except "bl_final_acorn",             amber.banned_other},
+        {G.P_BLINDS,  is_showdown_except "bl_final_acorn",  amber.banned_other},
-        {G.P_BLINDS,  is_showdown_except "bl_final_bell",              cerulean.banned_other},
+        {G.P_BLINDS,  is_showdown_except "bl_final_bell",   cerulean.banned_other},
-        {G.P_BLINDS,  is_showdown_except "bl_final_heart",             crimson.banned_other},
+        {G.P_BLINDS,  is_showdown_except "bl_final_heart",  crimson.banned_other},
-        {G.P_BLINDS,  is_showdown_except "bl_final_leaf",              verdant.banned_other},
+        {G.P_BLINDS,  is_showdown_except "bl_final_leaf",   verdant.banned_other},
-        {G.P_BLINDS,  is_showdown_except "bl_final_vessel",            violet.banned_other},
+        {G.P_BLINDS,  is_showdown_except "bl_final_vessel", violet.banned_other},
-        {G.P_BLINDS,  is_showdown_except "bl_Roland_venerable_visage", final.banned_other},
     }:each(function(v)
         f(v[1]):where(v[2]):each(adder(v[3]))
     end)