CHANGELOG.md

@@ -65,6 +65,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Removed
 - Medium and large potions from all loot tables
 - LoD pop-in effect
+- Removed Dullahans from halloween event
 
 ### Fixed
 - Fixed wild roaming cyclop loot table to not drop the quarry key

assets/common/entity/calendar/halloween/aggressive/halloween_dullahan.ron

-#![enable(implicit_some)]
-(
-    name: Name("Dullahan"),
-    body: RandomWith("dullahan"),
-    alignment: Alignment(Enemy),
-    loot: LootTable("common.loot_tables.calendar.halloween.halloween_dullahan"),
-    inventory: (
-        loadout: FromBody,
-    ),
-    meta: [],
-)
\ No newline at end of file

assets/common/loot_tables/calendar/halloween/halloween_dullahan.ron

-[
-    (1.0, Item("common.items.food.pumpkin_spice_brew")),
-    (5.0, Item("common.items.food.honeycorn")),
-]
\ No newline at end of file

assets/common/manifests/ship_manifest.ron

@@ -233,4 +233,40 @@
             19: Air(Lantern, 4),
         },
     ),
+    Cart: (
+        bone0: (
+            offset: (-3.5, -3.5, 0.5),
+            central: ("cart.structure"),
+        ),
+        bone1: (
+            offset: (-1.0, -2.5, -1.0),
+            central: ("cart.axle"),
+        ),
+        bone2: (
+            offset: (-1.0, -2.5, -1.0),
+            central: ("cart.axle"),
+        ),
+        bone3: (
+            offset: (0.0, 0.0, 0.0),
+            central: ("empty"),
+        ),
+
+        custom_indices: {
+            1: Air(ChairSingle, 4),
+            2: Air(Helm, 0),
+            3: Air(ChairSingle, 2),
+            4: Air(ChairSingle, 6),
+            9: Air(CraftingBench, 0),
+            10: Air(Window1, 0),
+            11: Air(RepairBench, 0),
+            12: Air(DismantlingBench, 4),
+            13: Air(Window1, 2),
+            14: Air(Crate, 0),
+            15: Air(Cauldron, 2),
+            16: Air(ChairSingle, 0),
+            17: Air(CookingPot, 0),
+            18: Air(WallLampSmall, 4),
+            19: Air(Lantern, 4),
+        },
+    ),
 })

assets/voxygen/audio/sfx.ron

@@ -129,6 +129,18 @@
             threshold: 5.0,
             subtitle: "subtitle-running_water",
         ),
+        Lavapool: (
+            files: [
+                "voxygen.audio.sfx.ambient.river_sounds.running_water-003",
+                "voxygen.audio.sfx.ambient.river_sounds.running_water-004",
+                "voxygen.audio.sfx.ambient.river_sounds.running_water-005",
+                "voxygen.audio.sfx.ambient.river_sounds.running_water-006",
+                "voxygen.audio.sfx.ambient.river_sounds.running_water-012",
+                "voxygen.audio.sfx.ambient.river_sounds.running_water-013",
+            ],
+            threshold: 7.0,
+            subtitle: "subtitle-lavapool",
+        ),
         //
         // Character States
         //

assets/voxygen/shaders/include/sky.glsl

@@ -804,4 +804,17 @@ vec3 simple_lighting(vec3 pos, vec3 col, float shade) {
     return col * clamp(2.5 / dot(d, d), shade * (get_sun_brightness() + 0.01), 1);
 }
 
+float wind_wave(float off, float scaling, float speed, float strength) {
+    float aspeed = abs(speed);
+
+    // TODO: Right now, the wind model is pretty simplistic. This means that there is frequently no wind at all, which
+    // looks bad. For now, we add a lower bound on the wind speed to keep things looking nice.
+    strength = max(strength, 6.0);
+    aspeed = max(aspeed, 5.0);
+
+    return (sin(tick_loop(2.0 * PI, 0.35 * scaling * floor(aspeed), off)) * (1.0 - fract(aspeed))
+        + sin(tick_loop(2.0 * PI, 0.35 * scaling * ceil(aspeed), off)) * fract(aspeed)) * abs(strength) * 0.25;
+    //return sin(tick.x * 1.5 * scaling + off) + sin(tick.x * 0.35 * scaling + off);
+}
+
 #endif

assets/voxygen/shaders/lod-terrain-frag.glsl

@@ -360,7 +360,10 @@ void main() {
     vec3 surf_color;
     float surf_alpha = 1.0;
     uint mat;
-    if (dot(pow(f_col_raw - vec3(0.02, 0.06, 0.22), uvec3(2)), vec3(1)) < 0.01 && dot(vec3(0, 0, 1), f_norm) > 0.9) {
+    // NOTE: On nvidea vulkan drivers a `pow` with negative base results in NaN even if the
+    // exponent is an integer.
+    vec3 water_col_diff = f_col_raw - vec3(0.02, 0.06, 0.22);
+    if (dot(water_col_diff * water_col_diff, vec3(1)) < 0.01 && dot(vec3(0, 0, 1), f_norm) > 0.9) {
         mat = MAT_FLUID;
         vec3 reflect_ray = cam_to_frag * vec3(1, 1, -1);
         #if (FLUID_MODE >= FLUID_MODE_MEDIUM)

assets/voxygen/shaders/rope-frag.glsl

+#version 420 core
+
+#define FIGURE_SHADER
+
+#include <constants.glsl>
+
+#define LIGHTING_TYPE LIGHTING_TYPE_REFLECTION
+
+#define LIGHTING_REFLECTION_KIND LIGHTING_REFLECTION_KIND_GLOSSY
+
+#if (FLUID_MODE == FLUID_MODE_LOW)
+    #define LIGHTING_TRANSPORT_MODE LIGHTING_TRANSPORT_MODE_IMPORTANCE
+#elif (FLUID_MODE >= FLUID_MODE_MEDIUM)
+    #define LIGHTING_TRANSPORT_MODE LIGHTING_TRANSPORT_MODE_RADIANCE
+#endif
+
+#define LIGHTING_DISTRIBUTION_SCHEME LIGHTING_DISTRIBUTION_SCHEME_MICROFACET
+
+#define LIGHTING_DISTRIBUTION LIGHTING_DISTRIBUTION_BECKMANN
+
+#define HAS_SHADOW_MAPS
+
+#include <globals.glsl>
+#include <light.glsl>
+#include <cloud.glsl>
+#include <lod.glsl>
+
+layout(location = 0) in vec3 f_pos;
+// in float dummy;
+// in vec3 f_col;
+// in float f_ao;
+// flat in uint f_pos_norm;
+layout(location = 1) in vec3 f_norm;
+layout(location = 2) in vec3 m_pos;
+// in float f_alt;
+// in vec4 f_shadow;
+// in vec3 light_pos[2];
+
+// #if (SHADOW_MODE == SHADOW_MODE_MAP)
+// in vec4 sun_pos;
+// #elif (SHADOW_MODE == SHADOW_MODE_CHEAP || SHADOW_MODE == SHADOW_MODE_NONE)
+// const vec4 sun_pos = vec4(0.0);
+// #endif
+
+//struct ShadowLocals {
+//  mat4 shadowMatrices;
+//    mat4 texture_mat;
+//};
+//
+//layout (std140)
+//uniform u_light_shadows {
+//    ShadowLocals shadowMats[/*MAX_LAYER_FACES*/192];
+//};
+
+layout (std140, set = 2, binding = 0)
+uniform u_locals {
+    vec4 pos_a;
+    vec4 pos_b;
+};
+
+layout(location = 0) out vec4 tgt_color;
+layout(location = 1) out uvec4 tgt_mat;
+
+void main() {
+    // vec2 texSize = textureSize(t_col_light, 0);
+    // vec4 col_light = texture(t_col_light, (f_uv_pos + 0.5) / texSize);
+    // vec3 f_col = col_light.rgb;
+    // float f_ao = col_light.a;
+
+    // vec4 f_col_light = texture(t_col_light, (f_uv_pos + 0.5) / textureSize(t_col_light, 0));
+    // vec3 f_col = f_col_light.rgb;
+    // float f_ao = f_col_light.a;
+
+    float f_ao = 1.0;
+    vec3 f_col = mix(
+        vec3(0.05, 0.03, 0.01),
+        vec3(0.1, 0.07, 0.05),
+        floor(abs(fract(m_pos.z * 10.0 + atan(m_pos.x, m_pos.y) * 0.159) - 0.5) * 6.0) / 3.0
+    );
+
+    #ifdef EXPERIMENTAL_BAREMINIMUM
+        tgt_color = vec4(simple_lighting(f_pos.xyz, f_col, f_ao), 1);
+        return;
+    #endif
+
+    // float /*f_light*/f_ao = textureProj(t_col_light, vec3(f_uv_pos, texSize)).a;//1.0;//f_col_light.a * 4.0;// f_light = float(v_col_light & 0x3Fu) / 64.0;
+
+    // vec3 my_chunk_pos = (vec3((uvec3(f_pos_norm) >> uvec3(0, 9, 18)) & uvec3(0x1FFu)) - 256.0) / 2.0;
+    // tgt_color = vec4(hash(floor(vec4(my_chunk_pos.x, 0, 0, 0))), hash(floor(vec4(0, my_chunk_pos.y, 0, 1))), hash(floor(vec4(0, 0, my_chunk_pos.z, 2))), 1.0);
+    // float f_ao = 0;
+    // tgt_color = vec4(vec3(f_ao), 1.0);
+    // tgt_color = vec4(f_col, 1.0);
+    // return;
+
+    // vec3 du = dFdx(f_pos);
+    // vec3 dv = dFdy(f_pos);
+    // vec3 f_norm = normalize(cross(du, dv));
+
+    // vec4 light_pos[2];
+//#if (SHADOW_MODE == SHADOW_MODE_MAP)
+//    // for (uint i = 0u; i < light_shadow_count.z; ++i) {
+//    //     light_pos[i] = /*vec3(*/shadowMats[i].texture_mat * vec4(f_pos, 1.0)/*)*/;
+//    // }
+//    vec4 sun_pos = /*vec3(*/shadowMats[0].texture_mat * vec4(f_pos, 1.0)/*)*/;
+//#elif (SHADOW_MODE == SHADOW_MODE_CHEAP || SHADOW_MODE == SHADOW_MODE_NONE)
+//    vec4 sun_pos = vec4(0.0);
+//#endif
+
+    vec3 cam_to_frag = normalize(f_pos - cam_pos.xyz);
+    // vec4 vert_pos4 = view_mat * vec4(f_pos, 1.0);
+    // vec3 view_dir = normalize(-vec3(vert_pos4)/* / vert_pos4.w*/);
+    vec3 view_dir = -cam_to_frag;
+
+    /* vec3 sun_dir = get_sun_dir(time_of_day.x);
+    vec3 moon_dir = get_moon_dir(time_of_day.x); */
+    // float sun_light = get_sun_brightness(sun_dir);
+    // float moon_light = get_moon_brightness(moon_dir);
+    /* float sun_shade_frac = horizon_at(f_pos, sun_dir);
+    float moon_shade_frac = horizon_at(f_pos, moon_dir); */
+#if (SHADOW_MODE == SHADOW_MODE_CHEAP || SHADOW_MODE == SHADOW_MODE_MAP || FLUID_MODE >= FLUID_MODE_MEDIUM)
+    float f_alt = alt_at(f_pos.xy);
+#elif (SHADOW_MODE == SHADOW_MODE_NONE || FLUID_MODE == FLUID_MODE_LOW)
+    float f_alt = f_pos.z;
+#endif
+
+#if (SHADOW_MODE == SHADOW_MODE_CHEAP || SHADOW_MODE == SHADOW_MODE_MAP)
+    vec4 f_shadow = textureBicubic(t_horizon, s_horizon, pos_to_tex(f_pos.xy));
+    float sun_shade_frac = horizon_at2(f_shadow, f_alt, f_pos, sun_dir);
+#elif (SHADOW_MODE == SHADOW_MODE_NONE)
+    float sun_shade_frac = 1.0;//horizon_at2(f_shadow, f_alt, f_pos, sun_dir);
+#endif
+    float moon_shade_frac = 1.0;// horizon_at2(f_shadow, f_alt, f_pos, moon_dir);
+    // Globbal illumination "estimate" used to light the faces of voxels which are parallel to the sun or moon (which is a very common occurrence).
+    // Will be attenuated by k_d, which is assumed to carry any additional ambient occlusion information (e.g. about shadowing).
+    // float ambient_sides = clamp(mix(0.5, 0.0, abs(dot(-f_norm, sun_dir)) * 10000.0), 0.0, 0.5);
+    // NOTE: current assumption is that moon and sun shouldn't be out at the sae time.
+    // This assumption is (or can at least easily be) wrong, but if we pretend it's true we avoids having to explicitly pass in a separate shadow
+    // for the sun and moon (since they have different brightnesses / colors so the shadows shouldn't attenuate equally).
+    // float shade_frac = /*1.0;*/sun_shade_frac + moon_shade_frac;
+
+    // DirectionalLight sun_info = get_sun_info(sun_dir, sun_shade_frac, light_pos);
+    DirectionalLight sun_info = get_sun_info(sun_dir, sun_shade_frac, /*sun_pos*/f_pos);
+    DirectionalLight moon_info = get_moon_info(moon_dir, moon_shade_frac/*, light_pos*/);
+
+    vec3 surf_color = f_col;
+
+    float alpha = 1.0;
+    const float n2 = 1.5;
+
+    const float R_s2s0 = pow((1.0 - n2) / (1.0 + n2), 2);
+    const float R_s1s0 = pow((1.3325 - n2) / (1.3325 + n2), 2);
+    const float R_s2s1 = pow((1.0 - 1.3325) / (1.0 + 1.3325), 2);
+    const float R_s1s2 = pow((1.3325 - 1.0) / (1.3325 + 1.0), 2);
+    float R_s = (f_pos.z < f_alt) ? mix(R_s2s1 * R_s1s0, R_s1s0, medium.x) : mix(R_s2s0, R_s1s2 * R_s2s0, medium.x);
+
+    vec3 k_a = vec3(1.0);
+    vec3 k_d = vec3(1.0);
+    vec3 k_s = vec3(R_s);
+
+    vec3 emitted_light, reflected_light;
+
+    // vec3 light_frac = /*vec3(1.0);*//*vec3(max(dot(f_norm, -sun_dir) * 0.5 + 0.5, 0.0));*/light_reflection_factor(f_norm, view_dir, vec3(0, 0, -1.0), vec3(1.0), vec3(R_s), alpha);
+    // vec3 point_light = light_at(f_pos, f_norm);
+    // vec3 light, diffuse_light, ambient_light;
+    //get_sun_diffuse(f_norm, time_of_day.x, view_dir, k_a * point_shadow * (shade_frac * 0.5 + light_frac * 0.5), k_d * point_shadow * shade_frac, k_s * point_shadow * shade_frac, alpha, emitted_light, reflected_light);
+    float max_light = 0.0;
+    // reflected_light *= point_shadow * shade_frac;
+    // emitted_light *= point_shadow * max(shade_frac, MIN_SHADOW);
+    // max_light *= point_shadow * shade_frac;
+    // reflected_light *= point_shadow;
+    // emitted_light *= point_shadow;
+    // max_light *= point_shadow;
+
+    vec3 cam_attenuation = vec3(1);
+    float fluid_alt = max(f_pos.z + 1, floor(f_alt + 1));
+    vec3 mu = medium.x == MEDIUM_WATER ? MU_WATER : vec3(0.0);
+    #if (FLUID_MODE >= FLUID_MODE_MEDIUM)
+        cam_attenuation =
+            medium.x == MEDIUM_WATER ? compute_attenuation_point(cam_pos.xyz, view_dir, mu, fluid_alt, /*cam_pos.z <= fluid_alt ? cam_pos.xyz : f_pos*/f_pos)
+            : compute_attenuation_point(f_pos, -view_dir, mu, fluid_alt, /*cam_pos.z <= fluid_alt ? cam_pos.xyz : f_pos*/cam_pos.xyz);
+    #endif
+
+    // Prevent the sky affecting light when underground
+    float not_underground = clamp((f_pos.z - f_alt) / 128.0 + 1.0, 0.0, 1.0);
+
+    max_light += get_sun_diffuse2(sun_info, moon_info, f_norm, view_dir, f_pos, mu, cam_attenuation, fluid_alt, k_a, k_d, k_s, alpha, f_norm, 1.0, emitted_light, reflected_light);
+
+    max_light += lights_at(f_pos, f_norm, view_dir, mu, cam_attenuation, fluid_alt, k_a, k_d, k_s, alpha, f_norm, 1.0, emitted_light, reflected_light);
+
+    // TODO: Hack to add a small amount of underground ambient light to the scene
+    reflected_light += vec3(0.01, 0.02, 0.03) * (1.0 - not_underground);
+
+    // Apply baked AO
+    float ao = f_ao * sqrt(f_ao);//0.25 + f_ao * 0.75; ///*pow(f_ao, 0.5)*/f_ao * 0.85 + 0.15;
+    reflected_light *= ao;
+    emitted_light *= ao;
+
+    // Apply point light AO
+    float point_shadow = shadow_at(f_pos, f_norm);
+    reflected_light *= point_shadow;
+    emitted_light *= point_shadow;
+
+    /* reflected_light *= cloud_shadow(f_pos); */
+    /* vec3 point_light = light_at(f_pos, f_norm);
+    emitted_light += point_light;
+    reflected_light += point_light; */
+    // get_sun_diffuse(f_norm, time_of_day.x, cam_to_frag, surf_color * f_light * point_shadow, 0.5 * surf_color * f_light * point_shadow, 0.5 * surf_color * f_light * point_shadow, 2.0, emitted_light, reflected_light);
+
+    // get_sun_diffuse(f_norm, time_of_day.x, light, diffuse_light, ambient_light, 1.0);
+    // diffuse_light *= point_shadow;
+    // ambient_light *= point_shadow;
+    // vec3 point_light = light_at(f_pos, f_norm);
+    // light += point_light;
+    // diffuse_light += point_light;
+    // reflected_light += point_light;
+    // vec3 surf_color = illuminate(srgb_to_linear(highlight_col.rgb * f_col), light, diffuse_light, ambient_light);
+
+    float reflectance = 0.0;
+    // TODO: Do reflectance properly like this later
+    vec3 reflect_color = vec3(0);
+
+    surf_color = illuminate(max_light, view_dir, mix(surf_color * emitted_light, reflect_color, reflectance), mix(surf_color * reflected_light, reflect_color, reflectance));
+
+    // if ((flags & 1) == 1 && int(cam_mode) == 1) {
+    //  float distance = distance(vec3(cam_pos), focus_pos.xyz) - 2;
+
+    //  float opacity = clamp(distance / distance_divider, 0, 1);
+
+    //  // if(threshold_matrix[int(gl_FragCoord.x) % 4][int(gl_FragCoord.y) % 4] > opacity) {
+    //     //     discard;
+    //     //     return;
+    //  // }
+    // }
+
+    tgt_color = vec4(surf_color, 1.0);
+    tgt_mat = uvec4(uvec3((f_norm + 1.0) * 127.0), MAT_FIGURE);
+}

assets/voxygen/shaders/rope-vert.glsl

+#version 420 core
+
+#include <constants.glsl>
+
+#define FIGURE_SHADER
+
+#define LIGHTING_TYPE LIGHTING_TYPE_REFLECTION
+
+#define LIGHTING_REFLECTION_KIND LIGHTING_REFLECTION_KIND_GLOSSY
+
+#define LIGHTING_TRANSPORT_MODE LIGHTING_TRANSPORT_MODE_IMPORTANCE
+
+#define LIGHTING_DISTRIBUTION_SCHEME LIGHTING_DISTRIBUTION_SCHEME_MICROFACET
+
+#define LIGHTING_DISTRIBUTION LIGHTING_DISTRIBUTION_BECKMANN
+
+#include <globals.glsl>
+#include <sky.glsl>
+
+layout(location = 0) in vec3 v_pos;
+layout(location = 1) in vec3 v_norm;
+
+layout (std140, set = 2, binding = 0)
+uniform u_locals {
+    vec4 pos_a;
+    vec4 pos_b;
+    float rope_length;
+};
+
+layout(location = 0) out vec3 f_pos;
+layout(location = 1) out vec3 f_norm;
+layout(location = 2) out vec3 m_pos;
+
+void main() {
+    m_pos = v_pos;
+
+    vec3 rz = normalize(pos_b.xyz - pos_a.xyz);
+    vec3 rx = normalize(cross(vec3(0, 0, 1), rz));
+    vec3 ry = normalize(cross(rz, rx));
+    float dist = distance(pos_a.xyz, pos_b.xyz);
+    vec3 pos = pos_a.xyz + (rx * v_pos.x + ry * v_pos.y) * 0.1 + rz * v_pos.z * dist;
+    vec2 ideal_wind_sway = wind_vel * vec2(
+        wind_wave(pos.y * 1.5, 1.9, wind_vel.x, wind_vel.y),
+        wind_wave(pos.x * 1.5, 2.1, wind_vel.y, wind_vel.x)
+    );
+    float dip = (1 - pow(abs(v_pos.z - 0.5) * 2.0, 2)) * max(rope_length - dist, 0.0);
+    pos += vec3(ideal_wind_sway * min(pow(dip, 2), 0.005), -0.5 * dip);
+
+    f_pos = pos + focus_pos.xyz;
+
+    #ifdef EXPERIMENTAL_CURVEDWORLD
+        f_pos.z -= pow(distance(f_pos.xy + focus_off.xy, focus_pos.xy + focus_off.xy) * 0.05, 2);
+    #endif
+
+    f_norm = rx * v_norm.x + ry * v_norm.y + rz * v_norm.z;
+
+    gl_Position = all_mat * vec4(f_pos, 1);
+}

assets/voxygen/shaders/sprite-vert.glsl

@@ -76,19 +76,6 @@ vec4 nearest_entity(in vec3 sprite_pos, const float entity_radius_factor) {
     return closest;
 }
 
-float wind_wave(float off, float scaling, float speed, float strength) {
-    float aspeed = abs(speed);
-
-    // TODO: Right now, the wind model is pretty simplistic. This means that there is frequently no wind at all, which
-    // looks bad. For now, we add a lower bound on the wind speed to keep things looking nice.
-    strength = max(strength, 6.0);
-    aspeed = max(aspeed, 5.0);
-
-    return (sin(tick_loop(2.0 * PI, 0.35 * scaling * floor(aspeed), off)) * (1.0 - fract(aspeed))
-        + sin(tick_loop(2.0 * PI, 0.35 * scaling * ceil(aspeed), off)) * fract(aspeed)) * abs(strength) * 0.25;
-    //return sin(tick.x * 1.5 * scaling + off) + sin(tick.x * 0.35 * scaling + off);
-}
-
 void main() {
     // Matrix to transform this sprite instance from model space to chunk space
     mat4 inst_mat;

assets/world/wildlife/spawn/calendar/halloween/jungle/area.ron

@@ -5,9 +5,8 @@ SpawnEntry (
         Pack(
             groups: [
                 (1, (1, 1, "common.entity.calendar.halloween.aggressive.halloween_harvester")),
-                (2, (1, 1, "common.entity.calendar.halloween.aggressive.halloween_dullahan")),
-                (3, (4, 8, "common.entity.wild.aggressive.bat")),
-                (3, (3, 6, "common.entity.calendar.halloween.aggressive.trickster")),
+                (4, (4, 8, "common.entity.wild.aggressive.bat")),
+                (4, (3, 6, "common.entity.calendar.halloween.aggressive.trickster")),
             ],
             spawn_mode: Land,
             calendar_events: Some([Halloween]),

assets/world/wildlife/spawn/calendar/halloween/taiga/core.ron

@@ -5,9 +5,8 @@ SpawnEntry (
         Pack(
             groups: [
                 (1, (1, 1, "common.entity.calendar.halloween.aggressive.halloween_harvester")),
-                (2, (1, 1, "common.entity.calendar.halloween.aggressive.halloween_dullahan")),
-                (3, (4, 8, "common.entity.wild.aggressive.bat")),
-                (3, (3, 6, "common.entity.calendar.halloween.aggressive.trickster")),
+                (4, (4, 8, "common.entity.wild.aggressive.bat")),
+                (4, (3, 6, "common.entity.calendar.halloween.aggressive.trickster")),
             ],
             spawn_mode: Land,
             calendar_events: Some([Halloween]),

assets/world/wildlife/spawn/calendar/halloween/temperate/rainforest.ron

@@ -5,9 +5,8 @@ SpawnEntry (
         Pack(
             groups: [
                 (1, (1, 1, "common.entity.calendar.halloween.aggressive.halloween_harvester")),
-                (2, (1, 1, "common.entity.calendar.halloween.aggressive.halloween_dullahan")),
-                (3, (4, 8, "common.entity.wild.aggressive.bat")),
-                (3, (3, 6, "common.entity.calendar.halloween.aggressive.trickster")),
+                (4, (4, 8, "common.entity.wild.aggressive.bat")),
+                (4, (3, 6, "common.entity.calendar.halloween.aggressive.trickster")),
             ],
             spawn_mode: Land,
             calendar_events: Some([Halloween]),

assets/world/wildlife/spawn/calendar/halloween/tropical/rainforest.ron

@@ -5,9 +5,8 @@ SpawnEntry (
         Pack(
             groups: [
                 (1, (1, 1, "common.entity.calendar.halloween.aggressive.halloween_harvester")),
-                (2, (1, 1, "common.entity.calendar.halloween.aggressive.halloween_dullahan")),
-                (3, (4, 8, "common.entity.wild.aggressive.bat")),
-                (3, (3, 6, "common.entity.calendar.halloween.aggressive.trickster")),
+                (4, (4, 8, "common.entity.wild.aggressive.bat")),
+                (4, (3, 6, "common.entity.calendar.halloween.aggressive.trickster")),
             ],
             spawn_mode: Land,
             calendar_events: Some([Halloween]),

assets/world/wildlife/spawn/calendar/halloween/tundra/core.ron

@@ -5,9 +5,8 @@ SpawnEntry (
         Pack(
             groups: [
                 (1, (1, 1, "common.entity.calendar.halloween.aggressive.halloween_harvester")),
-                (2, (1, 1, "common.entity.calendar.halloween.aggressive.halloween_dullahan")),
-                (3, (4, 8, "common.entity.wild.aggressive.bat")),
-                (3, (3, 6, "common.entity.calendar.halloween.aggressive.trickster")),
+                (4, (4, 8, "common.entity.wild.aggressive.bat")),
+                (4, (3, 6, "common.entity.calendar.halloween.aggressive.trickster")),
             ],
             spawn_mode: Land,
             calendar_events: Some([Halloween]),

assets/world/wildlife/spawn/calendar/halloween/tundra/forest.ron

@@ -5,9 +5,8 @@ SpawnEntry (
         Pack(
             groups: [
                 (1, (1, 1, "common.entity.calendar.halloween.aggressive.halloween_harvester")),
-                (2, (1, 1, "common.entity.calendar.halloween.aggressive.halloween_dullahan")),
-                (3, (4, 8, "common.entity.wild.aggressive.bat")),
-                (3, (3, 6, "common.entity.calendar.halloween.aggressive.trickster")),
+                (4, (4, 8, "common.entity.wild.aggressive.bat")),
+                (4, (3, 6, "common.entity.calendar.halloween.aggressive.trickster")),
             ],
             spawn_mode: Land,
             calendar_events: Some([Halloween]),

assets/world/wildlife/spawn/calendar/halloween/tundra/snow.ron

@@ -5,9 +5,8 @@ SpawnEntry (
         Pack(
             groups: [
                 (1, (1, 1, "common.entity.calendar.halloween.aggressive.halloween_harvester")),
-                (2, (1, 1, "common.entity.calendar.halloween.aggressive.halloween_dullahan")),
-                (3, (4, 8, "common.entity.wild.aggressive.bat")),
-                (3, (3, 6, "common.entity.calendar.halloween.aggressive.trickster")),
+                (4, (4, 8, "common.entity.wild.aggressive.bat")),
+                (4, (3, 6, "common.entity.calendar.halloween.aggressive.trickster")),
             ],
             spawn_mode: Land,
             calendar_events: Some([Halloween]),

assets/world/wildlife/spawn/taiga/area.ron

@@ -34,7 +34,8 @@ SpawnEntry (
                 (5, (1, 3, "common.entity.wild.peaceful.squirrel")),
                 (5, (1, 1, "common.entity.wild.peaceful.forest_fox")),
                 (5, (1, 3, "common.entity.wild.peaceful.raccoon")),
-                (2, (1, 1, "common.entity.wild.aggressive.dullahan")),
+                // TODO: Maybe reenable once the dullahan design is more carefully considered, or move it elsewhere (i.e: such as a haunted/ruins site)
+                //(2, (1, 1, "common.entity.wild.aggressive.dullahan")),
             ],
             spawn_mode: Land,
             day_period: [Night],