import pygame import random import math import sys # ============================================================ # STATIC ANOMALY FIELD # POV exploration game # Controls: # W / A / S / D or Arrow Keys = move # ESC = quit # ============================================================ pygame.init() WIDTH, HEIGHT = 1000, 700 screen = pygame.display.set_mode((WIDTH, HEIGHT)) pygame.display.set_caption("Static Anomaly Field") clock = pygame.time.Clock() # ------------------------------------------------------------ # WORLD SETTINGS # ------------------------------------------------------------ WORLD_W = 5000 WORLD_H = 5000 PLAYER_SPEED = 260 PLAYER_SPRINT = 1.8 ENTITY_COUNT = 28 CRASHER_COUNT = 14 CORE_POS = pygame.Vector2(WORLD_W / 2, WORLD_H / 2) CORE_RADIUS = 170 STATIC_CELL = 4 NOISE_POINTS = 26000 FONT = pygame.font.SysFont("consolas", 28, bold=True) SMALL_FONT = pygame.font.SysFont("consolas", 18) BIG_FONT = pygame.font.SysFont("consolas", 56, bold=True) # ------------------------------------------------------------ # COLORS # ------------------------------------------------------------ BG_BASE = (10, 60, 180) BLUE1 = (20, 70, 255) BLUE2 = (50, 140, 255) BLUE3 = (90, 210, 255) BLUE4 = (150, 240, 255) DARK = (0, 10, 35) WHITE = (240, 250, 255) RED = (255, 80, 100) # ------------------------------------------------------------ # PLAYER # ------------------------------------------------------------ player_pos = pygame.Vector2(WORLD_W * 0.25, WORLD_H * 0.25) player_vel = pygame.Vector2(0, 0) camera_shake = 0.0 glitch_timer = 0.0 signal_timer = 0.0 danger_amount = 0.0 game_over = False game_over_timer = 0.0 # ------------------------------------------------------------ # HELPER FUNCTIONS # ------------------------------------------------------------ def clamp(v, a, b): return max(a, min(b, v)) def lerp(a, b, t): return a + (b - a) * t def world_to_screen(world_pos, cam): return pygame.Vector2(world_pos.x - cam.x, world_pos.y - cam.y) def draw_text_center(surf, text, font, color, x, y): img = font.render(text, True, color) rect = img.get_rect(center=(x, y)) surf.blit(img, rect) def polygon_points(center, radius, sides, rot): pts = [] for i in range(sides): a = rot + (math.tau * i / sides) pts.append((center.x + math.cos(a) * radius, center.y + math.sin(a) * radius)) return pts # ------------------------------------------------------------ # STATIC BACKGROUND TEXTURE # Inspired by the image: blue moving noise / static field # ------------------------------------------------------------ noise_surface = pygame.Surface((WIDTH, HEIGHT)) static_overlay = pygame.Surface((WIDTH, HEIGHT), pygame.SRCALPHA) def render_static_background(surface, t, cam): surface.fill(BG_BASE) # animated fine noise arr = pygame.PixelArray(surface) for _ in range(NOISE_POINTS): x = random.randrange(WIDTH) y = random.randrange(HEIGHT) # drifting world-linked noise wx = x + int(cam.x * 0.18 + t * 50) wy = y + int(cam.y * 0.18 - t * 65) n = (wx * 928371 + wy * 364479 + int(t * 1000) * 19) & 255 if n < 40: c = surface.map_rgb((15, 50, 210)) elif n < 95: c = surface.map_rgb((25, 90, 255)) elif n < 150: c = surface.map_rgb((40, 140, 255)) elif n < 210: c = surface.map_rgb((80, 210, 255)) else: c = surface.map_rgb((130, 245, 255)) arr[x, y] = c del arr # Larger static pulses for _ in range(450): x = random.randrange(0, WIDTH, STATIC_CELL) y = random.randrange(0, HEIGHT, STATIC_CELL) a = random.randint(10, 45) col = random.choice([ (20, 70, 255, a), (50, 140, 255, a), (90, 210, 255, a), (150, 240, 255, a) ]) pygame.draw.rect(static_overlay, col, (x, y, STATIC_CELL, STATIC_CELL)) surface.blit(static_overlay, (0, 0)) static_overlay.fill((0, 0, 0, 0)) # subtle scanline effect for y in range(0, HEIGHT, 3): alpha = 10 + int(8 * math.sin(t * 3 + y * 0.05)) pygame.draw.line(surface, (0, 0, 0), (0, y), (WIDTH, y), 1) line = pygame.Surface((WIDTH, 1), pygame.SRCALPHA) line.fill((170, 220, 255, clamp(alpha, 0, 25))) surface.blit(line, (0, y)) # ------------------------------------------------------------ # ENTITIES # ------------------------------------------------------------ class BinaryEntity: def __init__(self): self.pos = pygame.Vector2( random.uniform(250, WORLD_W - 250), random.uniform(250, WORLD_H - 250) ) self.base_radius = random.uniform(18, 42) self.radius = self.base_radius self.sides = random.randint(3, 8) self.rot = random.uniform(0, math.tau) self.spin = random.uniform(-1.5, 1.5) self.pulse = random.uniform(0, 10) self.drift = pygame.Vector2(random.uniform(-20, 20), random.uniform(-20, 20)) self.mode = "polygon" def update(self, dt, t, player): self.rot += self.spin * dt self.pulse += dt * random.uniform(0.8, 1.4) self.pos += self.drift * dt if self.pos.x < 100 or self.pos.x > WORLD_W - 100: self.drift.x *= -1 if self.pos.y < 100 or self.pos.y > WORLD_H - 100: self.drift.y *= -1 dist = self.pos.distance_to(player) self.mode = "binary" if dist < 130 else "polygon" self.radius = self.base_radius + math.sin(self.pulse * 2.1) * 4 def draw(self, surf, cam, t): p = world_to_screen(self.pos, cam) if not (-200 <= p.x <= WIDTH + 200 and -200 <= p.y <= HEIGHT + 200): return if self.mode == "polygon": pts = polygon_points(p, self.radius, self.sides, self.rot) glow = pygame.Surface((WIDTH, HEIGHT), pygame.SRCALPHA) pygame.draw.polygon(glow, (120, 220, 255, 35), pts) pygame.draw.polygon(glow, (180, 250, 255, 100), pts, 2) surf.blit(glow, (0, 0)) pygame.draw.polygon(surf, (120, 220, 255), pts, 2) else: txt = "0101" wobx = math.sin(t * 8 + self.pos.x * 0.01) * 5 woby = math.cos(t * 7 + self.pos.y * 0.01) * 4 img = FONT.render(txt, True, (190, 255, 255)) rect = img.get_rect(center=(p.x + wobx, p.y + woby)) surf.blit(img, rect) # glitch copies img2 = FONT.render(txt, True, (60, 120, 255)) surf.blit(img2, (rect.x - 3, rect.y + 2)) img3 = FONT.render(txt, True, (255, 255, 255)) surf.blit(img3, (rect.x + 2, rect.y - 1)) class Crasher: def __init__(self): ang = random.uniform(0, math.tau) dist = random.uniform(260, 900) self.pos = CORE_POS + pygame.Vector2(math.cos(ang), math.sin(ang)) * dist self.vel = pygame.Vector2(0, 0) self.radius = random.uniform(20, 40) self.sides = random.randint(3, 7) self.rot = random.uniform(0, math.tau) self.spin = random.uniform(-4.0, 4.0) self.glitch = random.uniform(0, 100) def update(self, dt, t, player): to_core = CORE_POS - self.pos d = max(1, to_core.length()) self.vel += to_core.normalize() * (40 / max(1, d * 0.02)) * dt # hover around core region with weird jitter jitter = pygame.Vector2( math.sin(t * 11 + self.glitch) * 35, math.cos(t * 13 + self.glitch * 1.2) * 35 ) self.vel += jitter * 0.03 * dt # occasionally chase player if near core player_to_core = player.distance_to(CORE_POS) if player_to_core < 850: toward_player = player - self.pos if toward_player.length() > 0: self.vel += toward_player.normalize() * 28 * dt self.vel *= 0.985 self.pos += self.vel self.rot += self.spin * dt def draw(self, surf, cam, t): p = world_to_screen(self.pos, cam) if not (-200 <= p.x <= WIDTH + 200 and -200 <= p.y <= HEIGHT + 200): return # glitch draw for _ in range(3): ox = random.randint(-8, 8) oy = random.randint(-8, 8) pts = polygon_points( pygame.Vector2(p.x + ox, p.y + oy), self.radius + random.uniform(-5, 5), self.sides, self.rot + random.uniform(-0.3, 0.3) ) col = random.choice([ (255, 80, 100), (255, 255, 255), (80, 180, 255) ]) pygame.draw.polygon(surf, col, pts, 2) # ------------------------------------------------------------ # CORE # ------------------------------------------------------------ def draw_core(surf, cam, t, player): p = world_to_screen(CORE_POS, cam) dist = player.distance_to(CORE_POS) # pulling rings for i in range(8, 0, -1): rr = CORE_RADIUS + i * 30 + math.sin(t * 2.6 + i) * 16 alpha = clamp(120 - i * 10, 20, 140) ring = pygame.Surface((WIDTH, HEIGHT), pygame.SRCALPHA) pygame.draw.circle(ring, (110, 220, 255, alpha), (int(p.x), int(p.y)), int(rr), 2) surf.blit(ring, (0, 0)) # pooling / sucking effect swirl_count = 28 for i in range(swirl_count): ang = t * 1.5 + i * (math.tau / swirl_count) spiral_r = CORE_RADIUS + 70 + math.sin(t * 4 + i) * 18 x = p.x + math.cos(ang + spiral_r * 0.02) * spiral_r y = p.y + math.sin(ang + spiral_r * 0.02) * spiral_r size = 5 + (i % 3) pygame.draw.circle(surf, (160, 245, 255), (int(x), int(y)), size) # center core_glow = pygame.Surface((WIDTH, HEIGHT), pygame.SRCALPHA) for r, a in [(120, 20), (90, 35), (65, 60), (40, 95)]: pygame.draw.circle(core_glow, (120, 230, 255, a), (int(p.x), int(p.y)), r) surf.blit(core_glow, (0, 0)) pygame.draw.circle(surf, (220, 255, 255), (int(p.x), int(p.y)), 32) pygame.draw.circle(surf, (0, 70, 130), (int(p.x), int(p.y)), 18) # danger label if close if dist < 1000: txt = SMALL_FONT.render("CORE ANOMALY", True, (220, 245, 255)) surf.blit(txt, (p.x - txt.get_width() // 2, p.y - 95)) # ------------------------------------------------------------ # CREATE ENTITIES # ------------------------------------------------------------ entities = [BinaryEntity() for _ in range(ENTITY_COUNT)] crashers = [Crasher() for _ in range(CRASHER_COUNT)] # ------------------------------------------------------------ # GAME LOOP # ------------------------------------------------------------ time_elapsed = 0.0 while True: dt = clock.tick(60) / 1000.0 time_elapsed += dt for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() sys.exit() keys = pygame.key.get_pressed() if keys[pygame.K_ESCAPE]: pygame.quit() sys.exit() # -------------------------------------------------------- # INPUT # -------------------------------------------------------- move = pygame.Vector2(0, 0) if not game_over: if keys[pygame.K_w] or keys[pygame.K_UP]: move.y -= 1 if keys[pygame.K_s] or keys[pygame.K_DOWN]: move.y += 1 if keys[pygame.K_a] or keys[pygame.K_LEFT]: move.x -= 1 if keys[pygame.K_d] or keys[pygame.K_RIGHT]: move.x += 1 speed = PLAYER_SPEED if keys[pygame.K_LSHIFT] or keys[pygame.K_RSHIFT]: speed *= PLAYER_SPRINT if move.length() > 0: move = move.normalize() * speed player_vel = move # -------------------------------------------------------- # CORE PULL EFFECT # -------------------------------------------------------- to_core = CORE_POS - player_pos dist_to_core = max(1, to_core.length()) pull_strength = 0.0 if dist_to_core < 1400: pull_strength = (1.0 - dist_to_core / 1400.0) player_vel += to_core.normalize() * (pull_strength ** 2) * 250 * dt * 60 signal_timer = max(signal_timer, pull_strength * 0.9) danger_amount = pull_strength if not game_over: player_pos += player_vel * dt player_pos.x = clamp(player_pos.x, 0, WORLD_W) player_pos.y = clamp(player_pos.y, 0, WORLD_H) # -------------------------------------------------------- # UPDATE ENTITIES # -------------------------------------------------------- for e in entities: e.update(dt, time_elapsed, player_pos) active_crashers = [] if dist_to_core < 1200: active_crashers = crashers for c in crashers: c.update(dt, time_elapsed, player_pos) # collision with crasher = fake crash if c.pos.distance_to(player_pos) < c.radius + 25 and not game_over: game_over = True game_over_timer = 2.8 glitch_timer = 2.8 signal_timer = 1.0 # -------------------------------------------------------- # CAMERA # -------------------------------------------------------- cam = pygame.Vector2(player_pos.x - WIDTH / 2, player_pos.y - HEIGHT / 2) # shake near core or during crash camera_shake = danger_amount * 8 if glitch_timer > 0: camera_shake += 25 shake_x = random.uniform(-camera_shake, camera_shake) shake_y = random.uniform(-camera_shake, camera_shake) cam.x += shake_x cam.y += shake_y # -------------------------------------------------------- # DRAW BACKGROUND # -------------------------------------------------------- render_static_background(screen, time_elapsed, cam) # -------------------------------------------------------- # WORLD DISTORTION NEAR CORE # -------------------------------------------------------- if dist_to_core < 1300: overlay = pygame.Surface((WIDTH, HEIGHT), pygame.SRCALPHA) for _ in range(120): x = random.randint(0, WIDTH) y = random.randint(0, HEIGHT) a = random.randint(8, 35) pygame.draw.line( overlay, (150, 240, 255, a), (x, y), (x + random.randint(-18, 18), y + random.randint(-6, 6)), 1 ) screen.blit(overlay, (0, 0)) # -------------------------------------------------------- # DRAW CORE # -------------------------------------------------------- draw_core(screen, cam, time_elapsed, player_pos) # -------------------------------------------------------- # DRAW ENTITIES # -------------------------------------------------------- for e in entities: e.draw(screen, cam, time_elapsed) for c in active_crashers: c.draw(screen, cam, time_elapsed) # -------------------------------------------------------- # HUD / POV ONLY # -------------------------------------------------------- if not game_over: draw_text_center(screen, "+", BIG_FONT, (200, 245, 255), WIDTH // 2, HEIGHT // 2) # status text dist_label = SMALL_FONT.render(f"DIST TO CORE: {int(dist_to_core)}", True, WHITE) screen.blit(dist_label, (18, 18)) if dist_to_core < 1100: warn = SMALL_FONT.render("WARNING: CRASHERS DETECTED", True, RED) screen.blit(warn, (18, 44)) # -------------------------------------------------------- # GLITCH / SIGNAL EFFECTS # -------------------------------------------------------- if signal_timer > 0: signal_timer = max(0, signal_timer - dt * 0.22) alpha = int(90 * signal_timer) veil = pygame.Surface((WIDTH, HEIGHT), pygame.SRCALPHA) veil.fill((200, 255, 255, alpha)) screen.blit(veil, (0, 0)) if danger_amount > 0: ring_alpha = int(80 * danger_amount) vignette = pygame.Surface((WIDTH, HEIGHT), pygame.SRCALPHA) pygame.draw.rect(vignette, (255, 100, 100, ring_alpha), (0, 0, WIDTH, HEIGHT), 10) screen.blit(vignette, (0, 0)) if glitch_timer > 0: glitch_timer -= dt # horizontal glitch bars for _ in range(18): y = random.randint(0, HEIGHT - 8) h = random.randint(2, 10) sx = random.randint(-40, 40) band = screen.subsurface((0, y, WIDTH, h)).copy() screen.blit(band, (sx, y)) # white noise flashes if random.random() < 0.25: flash = pygame.Surface((WIDTH, HEIGHT), pygame.SRCALPHA) flash.fill((255, 255, 255, random.randint(25, 80))) screen.blit(flash, (0, 0)) # -------------------------------------------------------- # GAME OVER / FAKE CRASH # -------------------------------------------------------- if game_over: game_over_timer -= dt if random.random() < 0.35: for _ in range(350): x = random.randint(0, WIDTH - 1) y = random.randint(0, HEIGHT - 1) screen.set_at( (x, y), random.choice([ (255, 255, 255), (100, 180, 255), (255, 80, 100), (0, 0, 0) ]) ) draw_text_center(screen, "SIGNAL LOST", BIG_FONT, WHITE, WIDTH // 2, HEIGHT // 2 - 30) draw_text_center(screen, "SYSTEM FAILURE", FONT, RED, WIDTH // 2, HEIGHT // 2 + 30) if game_over_timer <= 0: pygame.quit() sys.exit() pygame.display.flip()