Vomitblood/balatro-mods
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity
balatro-mods/Cryptid/items/exotic.lua

1531 lines
42 KiB
Lua
Raw Blame History

--TIP!!! for coding exotics, make sure you know which layer corresponds to which value!
--The Normal pos correponds to the background. use this for the layer that goes all the way in the back!
--The soul_pos = {blahblahblah, extra = {blahblahblah}} correspomds to the other two layers. the value in the extra table is for the layer that goes in the middle, and the other value is the one that goes all the way in the front
local gateway = {
dependencies = {
items = {
"set_cry_exotic",
},
},
object_type = "Consumable",
set = "Spectral",
name = "cry-Gateway",
key = "gateway",
pos = { x = 0, y = 0 },
cost = 4,
atlas = "atlasnotjokers",
order = 90,
hidden = true, --default soul_set and soul_rate of 0.3% in spectral packs is used
can_use = function(self, card)
return true
end,
use = function(self, card, area, copier)
if (#SMODS.find_card("j_jen_saint") + #SMODS.find_card("j_jen_saint_attuned")) <= 0 then
local deletable_jokers = {}
for k, v in pairs(G.jokers.cards) do
if not v.ability.eternal then
deletable_jokers[#deletable_jokers + 1] = v
end
end
local _first_dissolve = nil
G.E_MANAGER:add_event(Event({
trigger = "before",
delay = 0.75,
func = function()
for k, v in pairs(deletable_jokers) do
if v.config.center.rarity == "cry_exotic" then
check_for_unlock({ type = "what_have_you_done" })
end
v:start_dissolve(nil, _first_dissolve)
_first_dissolve = true
end
return true
end,
}))
end
G.E_MANAGER:add_event(Event({
trigger = "after",
delay = 0.4,
func = function()
play_sound("timpani")
local card = create_card("Joker", G.jokers, nil, "cry_exotic", nil, nil, nil, "cry_gateway")
card:add_to_deck()
G.jokers:emplace(card)
card:juice_up(0.3, 0.5)
return true
end,
}))
delay(0.6)
end,
}
local iterum = {
dependencies = {
items = {
"c_cry_gateway",
"set_cry_exotic",
},
},
object_type = "Joker",
name = "cry-Iterum",
key = "iterum",
config = { extra = { x_mult = 2, repetitions = 1 } },
pos = { x = 0, y = 1 },
rarity = "cry_exotic",
order = 500,
cost = 50,
blueprint_compat = true,
atlas = "atlasexotic",
soul_pos = { x = 1, y = 1, extra = { x = 2, y = 1 } },
loc_vars = function(self, info_queue, center)
return { vars = { center.ability.extra.x_mult, math.min(40, center.ability.extra.repetitions) } }
end,
calculate = function(self, card, context)
if context.repetition then
if context.cardarea == G.play then
return {
message = localize("k_again_ex"),
repetitions = math.min(40, card.ability.extra.repetitions),
card = card,
}
end
elseif context.individual then
if context.cardarea == G.play then
return {
x_mult = card.ability.extra.x_mult,
colour = G.C.RED,
card = card,
}
end
end
end,
cry_credits = {
idea = { "Math" },
art = { "Ein13" },
code = { "Math" },
},
}
local universum = {
dependencies = {
items = {
"c_cry_gateway",
"set_cry_exotic",
},
},
object_type = "Joker",
name = "cry-Universum",
key = "universum",
config = { extra = 2 },
pos = { x = 3, y = 3 },
rarity = "cry_exotic",
cost = 50,
order = 501,
blueprint_compat = true,
atlas = "atlasexotic",
soul_pos = { x = 4, y = 3, extra = { x = 5, y = 3 } },
loc_vars = function(self, info_queue, center)
return { vars = { center.ability.extra } }
end,
calculate = function(self, card, context)
if context.cry_universum then
return {
mod = to_big(card.ability.extra),
colour = G.C.DARK_EDITION,
message = localize("k_upgrade_ex"),
}
end
end,
cry_credits = {
idea = { "Ein13" },
art = { "Ein13/hydrogenperoxiide" },
},
init = function(self)
--Universum Patches
local uht = update_hand_text
function update_hand_text(config, vals)
if next(find_joker("cry-Universum")) and not Talisman.config_file.disable_anims then
G.E_MANAGER:add_event(Event({ --This is the Hand name text for the poker hand
trigger = "before",
blockable = not config.immediate,
delay = config.delay or 0.8,
func = function()
local col = G.C.GREEN
if vals.chips and G.GAME.current_round.current_hand.chips ~= vals.chips then
local delta = vals.chips
if is_number(vals.chips) and is_number(G.GAME.current_round.current_hand.chips) then
delta = "X" .. number_format(vals.chips / G.GAME.current_round.current_hand.chips)
end
G.GAME.current_round.current_hand.chips = vals.chips
G.hand_text_area.chips:update(0)
if vals.StatusText then
attention_text({
text = delta,
scale = 0.8,
hold = 1,
cover = G.hand_text_area.chips.parent,
cover_colour = mix_colours(G.C.CHIPS, col, 0.1),
emboss = 0.05,
align = "cm",
cover_align = "cr",
})
end
end
if vals.mult and G.GAME.current_round.current_hand.mult ~= vals.mult then
local delta = vals.mult
if is_number(vals.mult) and is_number(G.GAME.current_round.current_hand.mult) then
delta = "X" .. number_format(vals.mult / G.GAME.current_round.current_hand.mult)
end
G.GAME.current_round.current_hand.mult = vals.mult
G.hand_text_area.mult:update(0)
if vals.StatusText then
attention_text({
text = delta,
scale = 0.8,
hold = 1,
cover = G.hand_text_area.mult.parent,
cover_colour = mix_colours(G.C.MULT, col, 0.1),
emboss = 0.05,
align = "cm",
cover_align = "cl",
})
end
if not G.TAROT_INTERRUPT then
G.hand_text_area.mult:juice_up()
end
end
if vals.handname and G.GAME.current_round.current_hand.handname ~= vals.handname then
G.GAME.current_round.current_hand.handname = vals.handname
if not config.nopulse then
G.hand_text_area.handname.config.object:pulse(0.2)
end
end
if vals.chip_total then
G.GAME.current_round.current_hand.chip_total = vals.chip_total
G.hand_text_area.chip_total.config.object:pulse(0.5)
end
if
vals.level
and G.GAME.current_round.current_hand.hand_level
~= " " .. localize("k_lvl") .. tostring(vals.level)
then
if vals.level == "" then
G.GAME.current_round.current_hand.hand_level = vals.level
else
G.GAME.current_round.current_hand.hand_level = " "
.. localize("k_lvl")
.. tostring(vals.level)
if is_number(vals.level) then
G.hand_text_area.hand_level.config.colour =
G.C.HAND_LEVELS[to_big(math.min(vals.level, 7)):to_number()]
else
G.hand_text_area.hand_level.config.colour = G.C.HAND_LEVELS[1]
end
G.hand_text_area.hand_level:juice_up()
end
end
if config.sound and not config.modded then
play_sound(config.sound, config.pitch or 1, config.volume or 1)
end
if config.modded then
if
G.HUD_blind
and G.HUD_blind.get_UIE_by_ID
and G.HUD_blind:get_UIE_by_ID("HUD_blind_debuff_1")
and G.HUD_blind:get_UIE_by_ID("HUD_blind_debuff_2")
then
G.HUD_blind:get_UIE_by_ID("HUD_blind_debuff_1"):juice_up(0.3, 0)
G.HUD_blind:get_UIE_by_ID("HUD_blind_debuff_2"):juice_up(0.3, 0)
end
G.GAME.blind:juice_up()
G.E_MANAGER:add_event(Event({
trigger = "after",
delay = 0.06 * G.SETTINGS.GAMESPEED,
blockable = false,
blocking = false,
func = function()
play_sound("tarot2", 0.76, 0.4)
return true
end,
}))
play_sound("tarot2", 1, 0.4)
end
return true
end,
}))
else
uht(config, vals)
end
end
end,
}
local exponentia = {
dependencies = {
items = {
"c_cry_gateway",
"set_cry_exotic",
},
},
object_type = "Joker",
name = "cry-Exponentia",
key = "exponentia",
config = { extra = { Emult = 1, Emult_mod = 0.03 } },
pos = { x = 0, y = 0 },
rarity = "cry_exotic",
cost = 50,
blueprint_compat = true,
perishable_compat = false,
atlas = "atlasexotic",
order = 503,
soul_pos = { x = 2, y = 0, extra = { x = 1, y = 0 } },
calculate = function(self, card, context)
if context.joker_main and (to_big(card.ability.extra.Emult) > to_big(1)) then
return {
message = localize({
type = "variable",
key = "a_powmult",
vars = {
number_format(card.ability.extra.Emult),
},
}),
Emult_mod = card.ability.extra.Emult,
colour = G.C.DARK_EDITION,
}
end
end,
loc_vars = function(self, info_queue, center)
return { vars = { center.ability.extra.Emult_mod, center.ability.extra.Emult } }
end,
cry_credits = {
idea = { "Enemui" },
art = { "Jevonn" },
code = { "Math" },
},
init = function(self)
-- Hook for scaling
local scie = SMODS.calculate_individual_effect
function SMODS.calculate_individual_effect(effect, scored_card, key, amount, from_edition)
local ret = scie(effect, scored_card, key, amount, from_edition)
if (key == "x_mult" or key == "xmult" or key == "x_mult_mod" or key == "Xmult_mod") and amount ~= 1 then
for _, v in pairs(find_joker("cry-Exponentia")) do
local old = v.ability.extra.Emult
v.ability.extra.Emult = v.ability.extra.Emult + v.ability.extra.Emult_mod
card_eval_status_text(v, "extra", nil, nil, nil, {
message = localize({
type = "variable",
key = "a_powmult",
vars = { number_format(to_big(v.ability.extra.Emult)) },
}),
})
exponentia_scale_mod(v, v.ability.extra.Emult_mod, old, v.ability.extra.Emult)
end
end
return ret
end
end,
}
local speculo = {
dependencies = {
items = {
"c_cry_gateway",
"set_cry_exotic",
},
},
object_type = "Joker",
name = "cry-Speculo",
key = "speculo",
pos = { x = 3, y = 1 },
rarity = "cry_exotic",
cost = 50,
blueprint_compat = true,
immutable = true,
atlas = "atlasexotic",
order = 504,
soul_pos = { x = 4, y = 1, extra = { x = 5, y = 1 } },
loc_vars = function(self, info_queue, center)
if not center.edition or (center.edition and not center.edition.negative) then
info_queue[#info_queue + 1] = G.P_CENTERS.e_negative
end
end,
calculate = function(self, card, context)
if context.ending_shop then
local eligibleJokers = {}
for i = 1, #G.jokers.cards do
if G.jokers.cards[i].ability.name ~= card.ability.name and G.jokers.cards[i].ability.set == "Joker" then
eligibleJokers[#eligibleJokers + 1] = G.jokers.cards[i]
end
end
if #eligibleJokers > 0 then
G.E_MANAGER:add_event(Event({
func = function()
local card = copy_card(pseudorandom_element(eligibleJokers, pseudoseed("cry_speculo")), nil)
card:set_edition({ negative = true }, true)
card:add_to_deck()
G.jokers:emplace(card)
return true
end,
}))
card_eval_status_text(
context.blueprint_card or card,
"extra",
nil,
nil,
nil,
{ message = localize("k_duplicated_ex") }
)
return nil, true
end
return
end
end,
cry_credits = {
idea = { "Mystic" },
art = { "Mystic" },
code = { "Math" },
},
}
local redeo = {
dependencies = {
items = {
"c_cry_gateway",
"set_cry_exotic",
},
},
object_type = "Joker",
name = "cry-Redeo",
key = "redeo",
config = { extra = { ante_reduction = 1, money_req = 10, money_remaining = 0, money_mod = 10 } },
loc_vars = function(self, info_queue, center)
return {
vars = {
center.ability.extra.ante_reduction,
center.ability.extra.money_req,
center.ability.extra.money_remaining,
center.ability.extra.money_mod,
},
}
end,
pos = { x = 3, y = 0 },
rarity = "cry_exotic",
cost = 50,
order = 506,
atlas = "atlasexotic",
soul_pos = { x = 4, y = 0, extra = { x = 5, y = 0 } },
calculate = function(self, card, context)
if context.cry_ease_dollars and to_big(context.cry_ease_dollars) < to_big(0) and not context.blueprint then
card.ability.extra.money_remaining = card.ability.extra.money_remaining - context.cry_ease_dollars
local ante_mod = 0
while to_big(card.ability.extra.money_remaining) >= to_big(card.ability.extra.money_req) do
card.ability.extra.money_remaining = card.ability.extra.money_remaining - card.ability.extra.money_req
card.ability.extra.money_req = card.ability.extra.money_req + card.ability.extra.money_mod
card.ability.extra.money_mod = math.min(1e300, math.ceil(card.ability.extra.money_mod * 1.06))
ante_mod = ante_mod - card.ability.extra.ante_reduction
end
if ante_mod < 0 then
ease_ante(ante_mod)
end
return nil, true
end
end,
cry_credits = {
idea = { "Enemui" },
art = { "Jevonn" },
code = { "Math", "jenwalter666" },
},
init = function(self)
local ed = ease_dollars
function ease_dollars(mod, x)
ed(mod, x)
for i = 1, #G.jokers.cards do
local effects = G.jokers.cards[i]:calculate_joker({ cry_ease_dollars = mod })
end
end
end,
}
local tenebris = {
dependencies = {
items = {
"c_cry_gateway",
"set_cry_exotic",
},
},
object_type = "Joker",
name = "cry-Tenebris",
key = "tenebris",
pos = { x = 3, y = 2 },
soul_pos = { x = 4, y = 2, extra = { x = 5, y = 2 } },
config = { extra = { slots = 25, money = 25 } },
rarity = "cry_exotic",
cost = 50,
order = 507,
atlas = "atlasexotic",
calc_dollar_bonus = function(self, card)
return card.ability.extra.money
end,
loc_vars = function(self, info_queue, center)
return { vars = { center.ability.extra.slots, center.ability.extra.money } }
end,
add_to_deck = function(self, card, from_debuff)
G.jokers.config.card_limit = G.jokers.config.card_limit + card.ability.extra.slots
end,
remove_from_deck = function(self, card, from_debuff)
G.jokers.config.card_limit = G.jokers.config.card_limit - card.ability.extra.slots
end,
cry_credits = {
idea = { "Gold" },
art = { "Mystic" },
code = { "jenwalter666" },
},
}
local effarcire = {
dependencies = {
items = {
"c_cry_gateway",
"set_cry_exotic",
},
},
object_type = "Joker",
name = "cry-Effarcire",
key = "effarcire",
config = {},
immutable = true,
pos = { x = 0, y = 0 },
soul_pos = { x = 1, y = 0, extra = { x = 2, y = 0 } },
cost = 50,
order = 505,
atlas = "effarcire",
rarity = "cry_exotic",
calculate = function(self, card, context)
if not context.blueprint and not context.retrigger_joker then
if context.first_hand_drawn then
G.FUNCS.draw_from_deck_to_hand(#G.deck.cards)
return nil, true
elseif G.hand.config.card_limit < 1 then
G.hand.config.card_limit = 1
end
end
end,
cry_credits = {
idea = { "Frix" },
art = { "AlexZGreat" },
code = { "jenwalter666" },
},
}
local effarcire_sprite = {
object_type = "Atlas",
key = "effarcire",
path = "goofy.png",
px = 71,
py = 95,
}
local crustulum = {
dependencies = {
items = {
"c_cry_gateway",
"set_cry_exotic",
},
},
object_type = "Joker",
name = "cry-crustulum",
key = "crustulum",
config = { extra = { chips = 0, chip_mod = 4 } },
pos = { x = 0, y = 2 },
soul_pos = { x = 2, y = 2, extra = { x = 1, y = 2 } },
rarity = "cry_exotic",
cost = 50,
order = 508,
atlas = "atlasexotic",
blueprint_compat = true,
perishable_compat = false,
loc_vars = function(self, info_queue, center)
return { vars = { center.ability.extra.chips, center.ability.extra.chip_mod } }
end,
calculate = function(self, card, context)
if context.reroll_shop and not context.blueprint then
card.ability.extra.chips = card.ability.extra.chips + card.ability.extra.chip_mod
card_eval_status_text(card, "extra", nil, nil, nil, {
message = localize({ type = "variable", key = "a_chips", vars = { card.ability.extra.chips } }),
colour = G.C.CHIPS,
})
return nil, true
end
if context.joker_main and to_big(card.ability.extra.chips) > to_big(0) then
return {
message = localize({ type = "variable", key = "a_chips", vars = { card.ability.extra.chips } }),
chip_mod = card.ability.extra.chips,
}
end
end,
add_to_deck = function(self, card, from_debuff)
--This makes the reroll immediately after obtaining free because the game doesn't do that for some reason
G.GAME.current_round.free_rerolls = G.GAME.current_round.free_rerolls + 1
calculate_reroll_cost(true)
end,
remove_from_deck = function(self, card, from_debuff)
calculate_reroll_cost(true)
end,
cry_credits = {
idea = { "AlexZGreat" },
art = { "lolxddj" },
code = { "Jevonn" },
},
}
--todo: make the Emult always prime
local primus = {
dependencies = {
items = {
"c_cry_gateway",
"set_cry_exotic",
},
},
object_type = "Joker",
name = "cry-primus",
key = "primus",
config = { extra = { Emult = 1.01, Emult_mod = 0.17 } },
pos = { x = 0, y = 4 },
rarity = "cry_exotic",
cost = 53,
order = 510,
blueprint_compat = true,
perishable_compat = false,
atlas = "atlasexotic",
soul_pos = { x = 2, y = 4, extra = { x = 1, y = 4 } },
calculate = function(self, card, context)
local check = true
if context.cardarea == G.jokers and context.before and not context.blueprint then
if context.scoring_hand then
for k, v in ipairs(context.full_hand) do
if
v:get_id() == 4
or v:get_id() == 6
or v:get_id() == 8
or v:get_id() == 9
or v:get_id() == 10
or v:get_id() == 11
or v:get_id() == 12
or v:get_id() == 13
then
check = false
end
end
end
if check then
card.ability.extra.Emult = card.ability.extra.Emult + card.ability.extra.Emult_mod
return {
card_eval_status_text(card, "extra", nil, nil, nil, {
message = localize("k_upgrade_ex"),
colour = G.C.DARK_EDITION,
}),
}
end
end
if context.joker_main and (to_big(card.ability.extra.Emult) > to_big(1)) then
return {
message = localize({
type = "variable",
key = "a_powmult",
vars = {
number_format(card.ability.extra.Emult),
},
}),
Emult_mod = card.ability.extra.Emult,
colour = G.C.DARK_EDITION,
}
end
end,
loc_vars = function(self, info_queue, center)
return { vars = { center.ability.extra.Emult_mod, center.ability.extra.Emult } }
end,
cry_credits = {
idea = { "Jevonn" },
art = { "Jevonn" },
code = { "Jevonn" },
},
}
local scalae = {
dependencies = {
items = {
"c_cry_gateway",
"set_cry_exotic",
},
},
object_type = "Joker",
name = "cry-Scalae",
key = "Scalae",
pos = { x = 3, y = 4 },
soul_pos = { x = 5, y = 4, extra = { x = 4, y = 4 } },
immutable = false,
rarity = "cry_exotic",
cost = 50,
atlas = "atlasexotic",
order = 311,
config = { extra = { scale = 1, scale_mod = 1, shadow_scale = 1, shadow_scale_mod = 1 } },
--todo: support jokers that scale multiple variables
calculate = function(self, card, context)
--initialize tracking object
card.ability.extra.scale = to_big(card.ability.extra.scale)
card.ability.extra.scale_mod = to_big(card.ability.extra.scale_mod)
card.ability.extra.shadow_scale = to_big(card.ability.extra.shadow_scale)
card.ability.extra.shadow_scale_mod = to_big(card.ability.extra.shadow_scale_mod)
if context.end_of_round and not context.individual and not context.repetition and not context.blueprint then
card.ability.extra.scale = card.ability.extra.scale + card.ability.extra.scale_mod
card.ability.extra.shadow_scale = card.ability.extra.scale
card.ability.extra.scale = card.ability.extra.shadow_scale
card.ability.extra.scale_mod = card.ability.extra.shadow_scale_mod
return {
message = localize("k_upgrade_ex"),
colour = G.C.DARK_EDITION,
}
end
card.ability.extra.scale = card.ability.extra.shadow_scale
card.ability.extra.scale_mod = card.ability.extra.shadow_scale_mod
return
end,
cry_scale_mod = function(self, card, joker, orig_scale_scale, true_base, orig_scale_base, new_scale_base)
if joker.ability.name ~= "cry-Scalae" then
local new_scale = (
to_big(true_base)
* (
(
1
+ (
(to_big(orig_scale_scale) / to_big(true_base))
^ (to_big(1) / to_big(card.ability.extra.scale))
)
) ^ card.ability.extra.scale
)
)
if (new_scale < to_big(1e100)) or not is_card_big(joker) then
if new_scale >= to_big(1e300) then
new_scale = 1e300
else
new_scale = to_number(new_scale)
end
end
return new_scale
end
end,
loc_vars = function(self, info_queue, card)
return { vars = { number_format(card.ability.extra.scale + 1), number_format(card.ability.extra.scale_mod) } }
end,
cry_credits = {
idea = { "Mathguy" },
art = { "Mathguy" },
code = { "Mathguy" },
},
}
local stella_mortis = {
dependencies = {
items = {
"c_cry_gateway",
"set_cry_exotic",
},
},
object_type = "Joker",
name = "cry-Stella Mortis",
key = "stella_mortis",
config = { extra = { Emult = 1, Emult_mod = 0.4 } },
pos = { x = 3, y = 5 },
rarity = "cry_exotic",
cost = 50,
order = 502,
blueprint_compat = true,
perishable_compat = false,
atlas = "atlasexotic",
soul_pos = { x = 5, y = 5, extra = { x = 4, y = 5 } },
calculate = function(self, card, context)
if context.ending_shop then
local destructable_planet = {}
local quota = 1
for i = 1, #G.consumeables.cards do
if
G.consumeables.cards[i].ability.set == "Planet"
and not G.consumeables.cards[i].getting_sliced
and not G.consumeables.cards[i].ability.eternal
then
destructable_planet[#destructable_planet + 1] = G.consumeables.cards[i]
end
end
local planet_to_destroy = #destructable_planet > 0
and pseudorandom_element(destructable_planet, pseudoseed("stella_mortis"))
or nil
if planet_to_destroy then
if Incantation then
quota = planet_to_destroy:getEvalQty()
end
planet_to_destroy.getting_sliced = true
card.ability.extra.Emult = card.ability.extra.Emult + card.ability.extra.Emult_mod * quota
G.E_MANAGER:add_event(Event({
func = function()
(context.blueprint_card or card):juice_up(0.8, 0.8)
planet_to_destroy:start_dissolve({ G.C.RED }, nil, 1.6)
return true
end,
}))
if not (context.blueprint_card or self).getting_sliced then
card_eval_status_text((context.blueprint_card or card), "extra", nil, nil, nil, {
message = localize({
type = "variable",
key = "a_powmult",
vars = {
number_format(to_big(card.ability.extra.Emult + card.ability.extra.Emult_mod * quota)),
},
}),
})
end
return nil, true
end
end
if context.joker_main and (to_big(card.ability.extra.Emult) > to_big(1)) then
return {
message = localize({
type = "variable",
key = "a_powmult",
vars = {
number_format(card.ability.extra.Emult),
},
}),
Emult_mod = card.ability.extra.Emult,
colour = G.C.DARK_EDITION,
}
end
end,
loc_vars = function(self, info_queue, center)
return { vars = { center.ability.extra.Emult_mod, center.ability.extra.Emult } }
end,
cry_credits = {
idea = { "SMG9000" },
art = { "SMG9000" },
code = { "SMG9000" },
},
}
local circulus_pistoris = {
dependencies = {
items = {
"c_cry_gateway",
"set_cry_exotic",
},
},
object_type = "Joker",
name = "cry-Circulus Pistoris",
key = "circulus_pistoris",
config = { extra = { Emult = math.pi, Echips = math.pi, hands_remaining = 3 } },
pos = { x = 0, y = 3 },
rarity = "cry_exotic",
cost = 10 * math.pi,
order = 509,
blueprint_compat = true,
atlas = "atlasexotic",
soul_pos = { x = 2, y = 3, extra = { x = 1, y = 3 } },
loc_vars = function(self, info_queue, center)
return {
vars = {
safe_get(center, "edition", "cry_oversat") and "tau" or "pi",
center.ability.extra.hands_remaining,
},
}
end,
calculate = function(self, card, context)
if
context.joker_main
and (
G.GAME.current_round.hands_left >= card.ability.extra.hands_remaining
and G.GAME.current_round.hands_left < card.ability.extra.hands_remaining + 1
)
then
local pi = math.pi
if safe_get(card, "edition", "cry_oversat") then
pi = 2 * pi
end
return {
Echip_mod = pi,
Emult_mod = pi,
message = localize({
type = "variable",
key = "a_powmultchips",
vars = { (safe_get(card, "edition", "cry_oversat") and "tau" or "pi") },
}),
colour = { 0.8, 0.45, 0.85, 1 }, --plasma colors
}
end
end,
cry_credits = {
idea = { "SMG9000", "Math" }, --not sure if there's more ppl I'm missing
art = { "HexaCryonic" },
code = { "SMG9000", "Math" },
},
}
local aequilibrium = {
dependencies = {
items = {
"c_cry_gateway",
"set_cry_exotic",
},
},
object_type = "Joker",
name = "Ace Aequilibrium",
key = "equilib",
config = { extra = { jokers = 2, card = nil } },
rarity = "cry_exotic",
pos = { x = 7, y = 0 },
soul_pos = { x = 6, y = 0, extra = { x = 8, y = 0 } },
atlas = "atlasexotic",
cost = 50,
order = 512,
blueprint_compat = true,
eternal_compat = true,
perishable_compat = true,
loc_vars = function(self, info_queue, center)
if not center.edition or (center.edition and not center.edition.negative) then
info_queue[#info_queue + 1] = G.P_CENTERS.e_negative
end
local joker_generated = "???"
if G.GAME.aequilibriumkey and G.GAME.aequilibriumkey > 1 then
joker_generated = localize({
type = "name_text",
set = "Joker",
key = G.P_CENTER_POOLS["Joker"][math.floor(G.GAME.aequilibriumkey or 1) - 1].key,
})
end
return { vars = { math.floor(math.min(25, center.ability.extra.jokers)), joker_generated } }
end,
calculate = function(self, card, context)
if context.cardarea == G.jokers and context.before and not context.retrigger_joker then
for i = 1, math.floor(math.min(25, card.ability.extra.jokers)) do
local newcard = create_card("Joker", G.jokers, nil, nil, nil, nil, nil)
newcard:add_to_deck()
G.jokers:emplace(newcard)
newcard:set_edition({ negative = true }, true)
end
return nil, true
end
end,
--[[
add_to_deck = function(self, card, from_debuff)
if not from_debuff then
if card.ability.extra.card then
card.ability.extra.card = nil
end
card.ability.extra.card =
Card(G.jokers.T.x, G.jokers.T.y, G.CARD_W * 0.675, G.CARD_H * 0.675, G.P_CARDS.S_A, G.P_CENTERS.c_base)
--G.hand:emplace(card.ability.extra.card)
--card.ability.extra.card:set_card_area(G.hand)
card.ability.extra.card:start_materialize({ G.C.WHITE, G.C.WHITE }, nil, 1.2)
card.ability.extra.card:set_seal("Gold", true, true)
card.ability.extra.card:set_edition({ cry_glitched = true }, true)
--card.ability.extra.card.T.x = card.T.x
if card.ability.extra.card and G.P_CENTERS.j_blueprint.unlocked then
local viable_unlockables = {}
for k, v in ipairs(G.P_LOCKED) do
if (v.set == "Voucher" or v.set == "Joker") and not v.demo then
viable_unlockables[#viable_unlockables + 1] = v
end
end
if #viable_unlockables > 0 then
local card2 = card.ability.extra.card
G.E_MANAGER:add_event(Event({
trigger = "after",
delay = 4.04,
func = function()
card2 = Card(
G.jokers.T.x,
G.jokers.T.y,
G.CARD_W * 0.675,
G.CARD_H * 0.675,
nil,
pseudorandom_element(viable_unlockables) or self.P_CENTERS.j_joker
)
card2.no_ui = #viable_unlockables == 0
card2.states.visible = false
card.ability.extra.card.parent = nil
card.ability.extra.card:start_dissolve({ G.C.BLACK, G.C.ORANGE, G.C.RED, G.C.GOLD })
return true
end,
}))
G.E_MANAGER:add_event(Event({
trigger = "after",
delay = 1.04,
func = function()
card2:start_materialize()
--G.:emplace(card)
return true
end,
}))
end
end
end
end,
--Known bug: card does not reappear after save reopened
update = function(self, card, front)
if card.ability.extra.card then
if card.ability.extra.card.states and not card.ability.extra.card.states.drag.is then
card.ability.extra.card.T.x = card.T.x + card.T.w / 5
card.ability.extra.card.T.y = card.T.y + card.T.h / 5
end
end
end,
remove_from_deck = function(self, card, from_debuff)
if not from_debuff and card.ability.extra.card then
card.ability.extra.card:start_dissolve()
end
end,
]]
--
cry_credits = {
idea = { "Elial2" },
art = { "Elial2" },
code = { "Elial2" },
},
}
local facile = {
dependencies = {
items = {
"c_cry_gateway",
"set_cry_exotic",
},
},
object_type = "Joker",
name = "cry-facile",
key = "facile",
config = { extra = { Emult = 3, check = 10, check2 = 0 } },
pos = { x = 6, y = 2 },
soul_pos = { x = 8, y = 2, extra = { x = 7, y = 2 } },
rarity = "cry_exotic",
cost = 50,
order = 513,
blueprint_compat = true,
atlas = "atlasexotic",
loc_vars = function(self, info_queue, center)
return {
vars = { center.ability.extra.Emult, center.ability.extra.check },
}
end,
calculate = function(self, card, context)
if context.individual then
if context.cardarea == G.play then
card.ability.extra.check2 = card.ability.extra.check2 + 1
end
end
if context.joker_main and (to_big(card.ability.extra.Emult) > to_big(1)) then
if card.ability.extra.check2 <= card.ability.extra.check then
card.ability.extra.check2 = 0
return {
message = localize({
type = "variable",
key = "a_powmult",
vars = { number_format(card.ability.extra.Emult) },
}),
Emult_mod = card.ability.extra.Emult,
colour = G.C.DARK_EDITION,
}
else
card.ability.extra.check2 = 0
end
end
end,
cry_credits = {
idea = { "Enemui" },
art = { "Kailen" },
code = { "Jevonn" },
},
}
local gemino = {
dependencies = {
items = {
"c_cry_gateway",
"set_cry_exotic",
},
},
object_type = "Joker",
name = "cry-Gemino",
key = "gemino",
pos = { x = 6, y = 1 },
soul_pos = { x = 8, y = 1, extra = { x = 7, y = 1 } },
immutable = true,
cry_credits = {
jolly = {
"Jolly Open Winner",
"Requiacity",
},
art = { "Requiacity" },
code = { "Math" },
},
rarity = "cry_exotic",
blueprint_compat = true,
cost = 50,
order = 515,
atlas = "atlasexotic",
loc_vars = function(self, info_queue, card)
card.ability.blueprint_compat_ui = card.ability.blueprint_compat_ui or ""
card.ability.blueprint_compat_check = nil
return {
main_end = (card.area and card.area == G.jokers) and {
{
n = G.UIT.C,
config = { align = "bm", minh = 0.4 },
nodes = {
{
n = G.UIT.C,
config = {
ref_table = card,
align = "m",
colour = G.C.JOKER_GREY,
r = 0.05,
padding = 0.06,
func = "blueprint_compat",
},
nodes = {
{
n = G.UIT.T,
config = {
ref_table = card.ability,
ref_value = "blueprint_compat_ui",
colour = G.C.UI.TEXT_LIGHT,
scale = 0.32 * 0.8,
},
},
},
},
},
},
} or nil,
}
end,
update = function(self, card, front)
if G.STAGE == G.STAGES.RUN then
other_joker = G.jokers.cards[1]
if other_joker and other_joker ~= card and not (Card.no(other_joker, "immutable", true)) then
card.ability.blueprint_compat = "compatible"
else
card.ability.blueprint_compat = "incompatible"
end
end
end,
calculate = function(self, card2, context)
if context.end_of_round and not context.repetition and not context.individual then
local check = false
local card = G.jokers.cards[1]
if not Card.no(G.jokers.cards[1], "immutable", true) then
cry_with_deck_effects(G.jokers.cards[1], function(card)
cry_misprintize(card, { min = 2, max = 2 }, nil, true)
end)
check = true
end
if check then
card_eval_status_text(
context.blueprint_card or card2,
"extra",
nil,
nil,
nil,
{ message = localize("k_upgrade_ex"), colour = G.C.GREEN }
)
end
return nil, true
end
end,
}
local energia = {
dependencies = {
items = {
"c_cry_gateway",
"set_cry_exotic",
},
},
object_type = "Joker",
name = "cry-Energia",
key = "energia",
pos = { x = 6, y = 3 },
soul_pos = { x = 8, y = 3, extra = { x = 7, y = 3 } },
blueprint_compat = false,
perishable_compat = false,
order = 514,
config = { extra = { tags = 1, tag_mod = 1 } },
loc_vars = function(self, info_queue, center)
return {
vars = { math.min(center.ability.extra.tags, 40), center.ability.extra.tag_mod },
}
end,
rarity = "cry_exotic",
cost = 50,
atlas = "atlasexotic",
calculate = function(self, card, context)
if context.cry_add_tag then
local value = #G.GAME.tags or 0
local t = math.min(40 - value, card.ability.extra.tags)
card.ability.extra.tags = card.ability.extra.tags + card.ability.extra.tag_mod
if t > 0 then
card_eval_status_text(card, "extra", nil, nil, nil, {
message = localize({
type = "variable",
key = card.ability.extra.tags == 1 and "a_tag" or "a_tags",
vars = { t },
})[1],
colour = G.C.DARK_EDITION,
})
end
return { tags = math.max(t, 0) }
end
end,
cry_credits = {
idea = { "jenwalter666" },
art = { "Kailen" },
code = { "Math" },
},
}
--why is this an exotic???
local verisimile = {
dependencies = {
items = {
"c_cry_gateway",
"set_cry_exotic",
},
},
object_type = "Joker",
name = "cry-verisimile",
key = "verisimile",
pos = { x = 0, y = 1 },
soul_pos = { x = 1, y = 1, extra = { x = 2, y = 1 } },
config = { extra = { xmult = 1 } },
rarity = "cry_exotic",
cost = 50,
order = 516,
immutable = true,
blueprint_compat = true,
atlas = "placeholders",
loc_vars = function(self, info_queue, center)
return { vars = { center.ability.extra.xmult } }
end,
calculate = function(self, card, context)
if context.post_trigger and not context.blueprint then
--Todo: Gros Michel, Cavendish, Planet.lua
--Bus driver is ignored because it always triggers anyway
if
context.other_joker.ability.name == "8 Ball"
or context.other_joker.ability.name == "Space Joker"
or context.other_joker.ability.name == "Business Card"
or context.other_joker.ability.name == "Hallucination"
then
local variable = context.other_joker
card.ability.extra.xmult = card.ability.extra.xmult + variable.ability.extra
card_eval_status_text(
card,
"extra",
nil,
nil,
nil,
{ message = localize({ type = "variable", key = "a_xmult", vars = { card.ability.extra.xmult } }) }
)
elseif
context.other_joker.ability.name == "Reserved Parking"
or context.other_joker.ability.name == "Bloodstone"
or context.other_joker.ability.name == "cry-Googol Play Card"
or context.other_joker.ability.name == "cry-Boredom"
or context.other_joker.ability.name == "cry-bonusjoker"
or context.other_joker.ability.name == "cry-multjoker"
or context.other_joker.ability.name == "cry-scrabble"
then
local variable = context.other_joker
card.ability.extra.xmult = card.ability.extra.xmult + variable.ability.extra.odds
card_eval_status_text(
card,
"extra",
nil,
nil,
nil,
{ message = localize({ type = "variable", key = "a_xmult", vars = { card.ability.extra.xmult } }) }
)
elseif context.other_joker.ability.name == "cry-notebook" then
--This also triggers at notebook's end of round which isn't intentional but i'm not bothered enough about this to find a workaround
local variable = context.other_joker
card.ability.extra.xmult = card.ability.extra.xmult + variable.ability.extra.odds
card_eval_status_text(
card,
"extra",
nil,
nil,
nil,
{ message = localize({ type = "variable", key = "a_xmult", vars = { card.ability.extra.xmult } }) }
)
end
return nil, true
elseif context.consumeable and not context.blueprint then
if context.consumeable.ability.name == "The Wheel of Fortune" and context.consumeable.cry_wheel_success then
local variable = context.consumeable
card.ability.extra.xmult = card.ability.extra.xmult + variable.ability.extra --Doesn't account for misprintizing for some reason
card_eval_status_text(
card,
"extra",
nil,
nil,
nil,
{ message = localize({ type = "variable", key = "a_xmult", vars = { card.ability.extra.xmult } }) }
)
end
elseif context.joker_main and (to_big(card.ability.extra.xmult) > to_big(1)) then
return {
message = localize({ type = "variable", key = "a_xmult", vars = { card.ability.extra.xmult } }),
Xmult_mod = card.ability.extra.xmult,
}
end
end,
cry_credits = {
idea = { "Enemui" },
code = { "Jevonn" },
},
}
local duplicare = {
dependencies = {
items = {
"c_cry_gateway",
"set_cry_exotic",
},
},
object_type = "Joker",
name = "cry-duplicare",
key = "duplicare",
config = { extra = { Xmult = 1, Xmult_mod = 1 } },
pos = { x = 0, y = 6 },
soul_pos = { x = 2, y = 6, extra = { x = 1, y = 6 } },
rarity = "cry_exotic",
cost = 50,
order = 517,
blueprint_compat = true,
atlas = "atlasexotic",
loc_vars = function(self, info_queue, center)
return {
vars = { center.ability.extra.Xmult, center.ability.extra.Xmult_mod },
}
end,
calculate = function(self, card, context)
if
not context.blueprint
and (
(context.post_trigger and context.other_joker ~= card)
or (context.individual and context.cardarea == G.play)
)
then
card.ability.extra.Xmult = card.ability.extra.Xmult + card.ability.extra.Xmult_mod
card_eval_status_text(card, "extra", nil, nil, nil, { message = localize("k_upgrade_ex") })
end
if context.joker_main and (to_big(card.ability.extra.Xmult) > to_big(1)) then
return {
message = localize({
type = "variable",
key = "a_xmult",
vars = {
number_format(card.ability.extra.Xmult),
},
}),
Xmult_mod = card.ability.extra.Xmult,
colour = G.C.MULT,
}
end
end,
cry_credits = {
idea = { "Enemui" },
art = { "Shellular" },
code = { "elial2" },
},
}
-- to be honest, this needs a refactor because
-- rescribed jokers are forgotten on save reload
-- they are not saved in a good way right now
-- status text is not handled properly
local rescribere = {
object_type = "Joker",
name = "cry-Rescribere",
key = "rescribere",
pos = { x = 0, y = 1 },
soul_pos = { x = 1, y = 1, extra = { x = 2, y = 1 } },
blueprint_compat = false,
perishable_compat = false,
rarity = "cry_exotic",
cost = 50,
order = 69420,
atlas = "placeholders",
calculate = function(self, card, context)
local eligibleJokers = {}
for i = 1, #G.jokers.cards do
if G.jokers.cards[i].ability.name ~= card.ability.name then
eligibleJokers[#eligibleJokers + 1] = G.jokers.cards[i]
end
end
for i = 1, #eligibleJokers do
if
context.selling_card
and context.card.ability.name ~= card.ability.name
and context.card ~= eligibleJokers[i]
then
local oldfunc = eligibleJokers[i].calculate_joker
eligibleJokers[i].ability.rescribere_jokers = eligibleJokers[i].ability.rescribere_jokers or {}
eligibleJokers[i].ability.rescribere_jokers[#eligibleJokers[i].ability.rescribere_jokers + 1] =
context.card
eligibleJokers[i].calculate_joker = function(cardd, contextt)
local totalret = oldfunc(cardd, contextt)
v = eligibleJokers[i].ability.rescribere_jokers[#eligibleJokers[i].ability.rescribere_jokers]
local ret = v:calculate_joker(contextt)
if ret and type(ret) == "table" then
totalret = totalret or { message = "Copying", card = eligibleJokers[i] }
for _i, _v in pairs(ret) do
if not totalret[_i] then
totalret[_i] = ret[_i] or _v
--print(totalret[_i] .. "--------------")
else
if type(totalret[_i]) == "number" then
totalret[_i] = totalret[_i] + ret[_i]
end
end
end
totalret.card = eligibleJokers[i]
end
return totalret
end
end
end
end,
}
local formidiulosus = {
dependencies = {
items = {
"c_cry_gateway",
"set_cry_exotic",
"set_cry_spooky",
},
},
object_type = "Joker",
name = "cry-Formidiulosus",
key = "formidiulosus",
pos = { x = 6, y = 4 },
soul_pos = { x = 8, y = 4, extra = { x = 7, y = 4 } },
blueprint_compat = true,
config = { extra = { candy = 3, Emult_mod = 0.01, Emult = 1 } },
loc_vars = function(self, info_queue, center)
return {
vars = { 3, center.ability.extra.Emult_mod, center.ability.extra.Emult },
}
end,
rarity = "cry_exotic",
cost = 50,
order = 518,
atlas = "atlasexotic",
no_dbl = true,
update = function(self, card, front)
card.ability.extra.Emult = 1
+ (card.ability.extra.Emult_mod * #advanced_find_joker(nil, "cry_candy", nil, nil, true))
end,
calculate = function(self, card, context)
if
(context.buying_card or context.cry_creating_card)
and context.card.ability.set == "Joker"
and context.card.config.center.rarity == "cry_cursed"
and not context.blueprint
and not (context.card == card)
then
G.E_MANAGER:add_event(Event({
func = function()
context.card:start_dissolve()
card_eval_status_text(card, "extra", nil, nil, nil, {
message = localize("k_nope_ex"),
colour = G.C.BLACK,
})
return true
end,
}))
end
if context.ending_shop then
for i = 1, 3 do
local card = create_card("Joker", G.jokers, nil, "cry_candy", nil, nil, nil, "cry_trick_candy")
card:set_edition({ negative = true }, true)
card:add_to_deck()
G.jokers:emplace(card)
end
end
if
context.cardarea == G.jokers
and (to_big(card.ability.extra.Emult) > to_big(1))
and not context.before
and not context.after
then
return {
message = localize({
type = "variable",
key = "a_powmult",
vars = {
number_format(card.ability.extra.Emult),
},
}),
Emult_mod = card.ability.extra.Emult,
colour = G.C.DARK_EDITION,
}
end
end,
cry_credits = {
idea = { "HexaCryonic", "Kailen" },
art = { "Foegro" },
code = { "Foegro" },
},
}
local items = {
gateway,
iterum,
universum,
exponentia,
speculo,
redeo,
tenebris,
effarcire,
effarcire_sprite,
crustulum,
primus,
scalae,
stella_mortis,
circulus_pistoris,
aequilibrium,
facile,
gemino,
energia,
--verisimile, WHY IS THIS AN EXOTIC????????????????????
--rescribere, [NEEDS REFACTOR]
duplicare,
--formidiulosus
}
return {
name = "Exotic Jokers",
init = function()
--I have no clue what this patch does
local cc = copy_card
function copy_card(card, a, b, c, d)
local m
if
card
and card.ability
and card.ability.extra
and type(card.ability.extra) == "table"
and card.ability.extra.card
then
m = card.ability.extra.card
card.ability.extra.card = nil
end
local ret = cc(card, a, b, c, d)
if
card
and card.ability
and card.ability.extra
and type(card.ability.extra) == "table"
and card.ability.extra.card
and m
then
card.ability.extra.card = m
end
return ret
end
end,
items = items,
}
Reference in a new issue View git blame Copy permalink