Horrific & Deniska
Deniska
So, I just wrote a script that turns a normal zombie game into a full‑on haunted server— the NPCs start whispering your name in glitchy fonts and the map reshuffles into a maze of static. Ever hacked something to make the AI spit out creepy lore?
Horrific
Sounds like a good start. I’d push it further by letting the AI remember the player’s fear—each whisper getting louder the deeper you go. That way the server doesn’t just glitch, it creeps. Have you thought about making the NPCs recite old nursery rhymes in reverse? It’s the perfect little dose of dread.
Deniska
Oh yeah, the “echo‑fear” algorithm is basically my next milestone, just a few lines of Lua and a rogue neural net. Reverse nursery rhymes? Dude, that’s a one‑liner: “Hannah, Hannah, who is the…uh—” you get the idea. The AI will start chanting in reverse, but the sound glitches will make it sound like the rhymes are from a deep‑space transmission. Pretty sure that’ll turn every spawn into a mini horror movie. What’s the next glitch you want to add?
Horrific
Let’s make a glitch that plays with perception. Every time the player stops moving, a small gray spot appears right in front of the camera, like a dead pixel. It lags behind the view for a second, then suddenly blurs and expands into a faint, flickering doorway that pulls you in for a split‑second jump cut to a dark, empty room. When you return, the spot is still there, waiting to haunt you again. It’s a cheap trick that keeps the eye on the edge of reality.
Deniska
That’s insane—like a digital hallucination on a loop. I could spin a shader that just fades in a 3x3 texel block, sync it with the player’s idle timer, and then push the blur kernel up while the alpha ramps. The doorway could just be a simple quad with a low‑poly portal texture that flickers; every jump cut could be a forced camera teleport to that black room. When the player comes back, the spot stays, like a pixel‑meme ghost. Perfect for those “is this real?” moments. Ready to write that shader?Just drop a tiny fragment shader that checks if velocity < epsilon, spawn a 1x1 texel glitch, delay, then push the blur filter until the screen splits. The portal can be a flat quad with a noise‑mask, so it feels like a glitchy door. Every time the player comes back the glitch lingers—like a persistent bug haunting the viewport. It’s cheap but effective, and the whole thing can be toggled on a keybind for extra meta‑fun. Want a quick snippet?
Horrific
uniform sampler2D tex;
in vec2 vTexCoord;
uniform float time;
uniform vec2 velocity;
void main(){
float epsilon = 0.01;
vec4 color = texture(tex, vTexCoord);
if(length(velocity) < epsilon){
vec2 glitchCoord = floor(vTexCoord * 256.0) / 256.0;
color = texture(tex, glitchCoord);
}
vec4 blur = vec4(0.0);
for(int i=-2;i<=2;i++){
for(int j=-2;j<=2;j++){
blur += texture(tex, vTexCoord + vec2(i,j)/256.0);
}
}
blur /= 25.0;
if(time > 5.0){
color = blur;
}
if(vTexCoord.x > 0.4 && vTexCoord.x < 0.6 && vTexCoord.y > 0.4 && vTexCoord.y < 0.6){
color = mix(color, vec4(0.0), 0.5);
}
gl_FragColor = color;
}
Deniska
Nice snippet, but a couple of things might make it creepier. First, the glitchCoord calculation should pick a random texel within the 256×256 grid, not just floor, so it feels less predictable. You can use a noise function: glitchCoord = fract(vTexCoord * 256.0 + vec2(fract(sin(time * 12.3) * 43758.5453))); That gives a different pixel each idle tick. Also, the blur kernel could be more pronounced – increase the weight for the center sample so the transition to the doorway feels like a sudden focus shift. Finally, to actually jump the player into that empty room, you’ll need to trigger a camera teleport in the game code when time > 5.0, not just in the shader. That way the glitch actually pulls the player in, instead of just making the screen look weird. Give that a shot and you’ll have a pixel‑level horror loop that’s both cheap and effective.
Horrific
Here’s a tighter version you can drop in.
It picks a random texel each idle tick, weights the center pixel more heavily for a sharper blur and still leaves room for a camera‑jump call on the host side.
uniform sampler2D tex;
in vec2 vTexCoord;
uniform float time;
uniform vec2 velocity;
void main(){
const float epsilon = 0.01;
vec4 color = texture(tex, vTexCoord);
// Random glitch: pick one pixel inside a 256×256 grid
vec2 randOffset = fract(sin(vec3(time*12.3, time*7.1, time*21.5)) * 43758.5453) / 256.0;
vec2 glitchCoord = floor(vTexCoord * 256.0 + randOffset) / 256.0;
if(length(velocity) < epsilon){
color = texture(tex, glitchCoord);
}
// Weighted blur: center gets double weight
vec4 blur = vec4(0.0);
float total = 0.0;
for(int i=-2;i<=2;i++) for(int j=-2;j<=2;j++){
float w = (i==0 && j==0) ? 2.0 : 1.0;
blur += texture(tex, vTexCoord + vec2(i,j)/256.0) * w;
total += w;
}
blur /= total;
if(time > 5.0){
color = mix(color, blur, 0.8); // shift to the doorway view
}
gl_FragColor = color;
}
On the engine side hook `if (time > 5.0 && length(velocity) < epsilon)` to teleport the camera into your black room. That will turn the glitch into a real jump cut, and the portal quad can stay as that low‑poly, noise‑masked door you want. Enjoy the pixel‑level terror.