Dev

Entropy.lua

@@ -1,7 +1,9 @@
 local mod_path = "" .. SMODS.current_mod.path
 Entropy.path = mod_path
 
-SMODS.load_file("lib/utils.lua")()
+assert(Spectrallib, "Please make sure Spectrallib is installed instead of Cryptlib\nhttps://github.com/SpectralPack/Spectrallib/")
+
+assert(SMODS.load_file("lib/utils.lua"))()
 
 local i = {
     "lib/colours",
@@ -37,7 +39,7 @@ local i = {
     --"items/jokers/epic_jokers",
     --"items/jokers/exotic_jokers",
     "items/jokers/rlegendary_jokers",
-    --"items/jokers/entropic_jokers",
+    "items/jokers/entropic_jokers",
 
     "items/jokers/dice_jokers",
 
@@ -55,6 +57,8 @@ local i = {
     "items/altpath/blinds",
     "items/misc/runes",
 
+    "items/jokers/void_jokers",
+
     "compat/compat_loader"
 }
 Entropy.load_files(i)
@@ -70,7 +74,7 @@ if not Cryptid.mod_gameset_whitelist then Cryptid.mod_gameset_whitelist = {} end
 Cryptid.mod_gameset_whitelist["entr"] = true
 Cryptid.mod_gameset_whitelist["Entropy"] = true
 
-Entropy.UpdateDailySeed()
+Entropy.update_daily_seed()
 
 if Entropy.config.family_mode then
     Cryptid_config.family_mode = true
@@ -102,4 +106,53 @@ SMODS.current_mod.calculate = function(self, context)
 end
 if G.P_CENTERS.e_negative then
     G.P_CENTERS.e_negative.no_doe = true
-end
+end
+
+SMODS.current_mod.menu_cards = function()
+    return {
+        func = function()
+            for i, v in pairs(G.title_top.cards) do
+                if v.config.center.key == "c_cryptid" then
+                    G.title_top:remove_card(v)
+                    v:remove()
+                end
+                if v.base and v.base.value and v.base.value == "Ace" then
+                    --G.title_top:remove_card(v)
+                    --v:remove()
+                    v:set_base()
+                    G.P_CENTERS.j_entr_title_card.discovered = true
+                    v:set_ability(G.P_CENTERS.j_entr_title_card)
+                    if v.children.front then
+                        v.children.front:remove()
+                        v.children.front = nil
+                    end
+                    math.randomseed(os.time())
+                    if math.random() < 0.01 then
+                        v:set_edition("e_entr_freaky") 
+                    else
+                        v:set_edition("e_entr_solar") 
+                    end
+                end
+            end
+        end,
+    }
+end
+
+SMODS.Joker {
+    key = "title_card",
+    atlas = "titlecard",
+    no_collection = true,
+    in_pool = function() return false end,
+    rarity = "entr_zenith",
+    pos = {x=0, y=0},
+    soul_pos = {x=1, y=0},
+    no_doe = true,
+    no_collection = true,
+    display_size = { w = 122, h = 122 },
+	in_pool = function()
+		return false
+	end,
+    cry_order = 999999,
+    discovered = true,
+    unlocked = true
+}

README.md

@@ -3,7 +3,7 @@
 A Chaotic Balatro mod focused on Inverted Consumables and expanding on Vanilla mechanics in various other ways
 Generally Vanilla adjacent but not exactly Vanilla+
 
-[Download CryptLib](https://github.com/SpectralPack/Cryptlib)
+[Download SpectralLib](https://github.com/SpectralPack/Spectrallib/)
 
 Entropy currently adds:
 

assets/shaders/eeshader.fs

@@ -0,0 +1,212 @@
+#if defined(VERTEX) || __VERSION__ > 100 || defined(GL_FRAGMENT_PRECISION_HIGH)
+	#define PRECISION highp
+#else
+	#define PRECISION mediump
+#endif
+
+// Card rotation
+extern PRECISION vec2 eeshader;
+
+extern PRECISION number dissolve;
+extern PRECISION number realtime;
+extern PRECISION number     time;
+extern PRECISION vec4 texture_details;
+extern PRECISION vec2 image_details;
+extern bool shadow;
+extern PRECISION vec4 burn_colour_1;
+extern PRECISION vec4 burn_colour_2;
+extern Image second_image;
+
+
+
+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.);
+	hsl.y = 0.0;
+	hsl.z = hsl.z;
+	return hsl;
+}
+
+#define PI 3.14159265358979323846
+
+float rand(vec2 c){
+	return fract(sin(dot(c.xy ,vec2(12.9898,78.233))) * 43758.5453);
+}
+
+float noise(vec2 p, float freq ){
+	float unit = 1./freq;
+	vec2 ij = floor(p/unit);
+	vec2 xy = mod(p,unit)/unit;
+	//xy = 3.*xy*xy-2.*xy*xy*xy;
+	xy = .5*(1.-cos(PI*xy));
+	float a = rand((ij+vec2(0.,0.)));
+	float b = rand((ij+vec2(1.,0.)));
+	float c = rand((ij+vec2(0.,1.)));
+	float d = rand((ij+vec2(1.,1.)));
+	float x1 = mix(a, b, xy.x);
+	float x2 = mix(c, d, xy.x);
+	return mix(x1, x2, xy.y);
+}
+
+float pNoise(vec2 p, int res){
+	float persistance = .5;
+	float n = 0.;
+	float normK = 0.;
+	float f = 4.;
+	float amp = 1.;
+	int iCount = 0;
+	for (int i = 0; i<50; i++){
+		n+=amp*noise(p, f);
+		f*=2.;
+		normK+=amp;
+		amp*=persistance;
+		if (iCount == res) break;
+		iCount++;
+	}
+	float nf = n/normK;
+	return nf*nf*nf*nf;
+}
+
+vec4 dissolve_mask(vec4 final_pixel, vec2 texture_coords, vec2 uv);
+// texture_coords = coolds of a original_pixel within the atlas texture
+vec4 effect( vec4 colour, Image texture, vec2 texture_coords, vec2 screen_coords )
+{
+    vec4 tex = Texel( texture, texture_coords);
+    vec2 real_uv = screen_coords;
+	vec2 uv = screen_coords;
+
+    float dummy = 2;
+    if(shadow) {dummy = 3;}
+    if(uv.x > uv.x * 2) {uv = eeshader*dissolve*burn_colour_1.x*burn_colour_2.x*time*dummy;}
+
+    float sprite_width = texture_details.z / image_details.x; // Normalized width
+    float min_x = texture_details.x * sprite_width; // min X
+    float max_x = (texture_details.x + 1.) * sprite_width; // max X
+
+    float tilt_normalized = eeshader.x;
+
+    float shiftX = 2.5 * sin(uv.y * (10.16 + 30.0 * uv.y * uv.y) + tilt_normalized * 1.5) // sine shift + affected by card rotation
+                                            / image_details.x; // shift X so normalize by X
+
+    float newX = min(max_x, max(min_x, texture_coords.x + shiftX));
+
+    uv /= 20.;
+    float x = screen_coords.x-.5;
+    float y = screen_coords.y-.5;
+    float a = 1.-sqrt(x*x + y*y);
+    a=sqrt(a);
+    uv += uv.y*0.15;
+	vec2 q = uv.xy;
+    vec2 p = -1.0+2.0*q;
+	//p.x *= image_details.x/image_details.y;
+	// Rain
+    vec4 col2 = vec4(0,0,0,1);
+	vec2 st =  p * vec2(.5, .01)+vec2(-(realtime)*6.-q.y*.6*-0.0, -(realtime)*6.);
+    float f = floor(mod((realtime)/9., 2.0));
+	f = (pNoise(st, 10)+1.) * (pNoise(st*.733, 10) + 1.) * 1.55 / 4.;
+	f = clamp(pow(abs(f), 12.0) * 13.0, 0.0, q.y*.14);    
+	col2 += f*8.;
+    col2.g = 0.0;
+    col2.b = 0.0;
+    col2.a = 1;
+
+	return tex*0.65 + col2;
+}
+
+
+
+vec4 dissolve_mask(vec4 final_pixel, vec2 texture_coords, vec2 uv)
+{
+    if (dissolve < 0.001) {
+        return vec4(shadow ? vec3(0.,0.,0.) : final_pixel.xyz, shadow ? final_pixel.a*0.3: final_pixel.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 (final_pixel.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) {
+            final_pixel.rgba = burn_colour_1.rgba;
+        } else if (burn_colour_2.a > 0.01) {
+            final_pixel.rgba = burn_colour_2.rgba;
+        }
+    }
+
+    return vec4(shadow ? vec3(0.,0.,0.) : final_pixel.xyz, res > adjusted_dissolve ? (shadow ? final_pixel.a*0.3: final_pixel.a) : .0);
+}
+
+
+
+extern PRECISION vec2 mouse_screen_pos;
+extern PRECISION float hovering;
+extern PRECISION 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