PURE SINGULARITY - TW.2s4.me Console Script

// PURE EXPLOSION + SINGULARITY - TW.2s4.me Console Script
// No emojis, just raw destructive power

console.log(`
████████████████████████████████████████████████████████████████████████████████
█                                                                              █
█                        PURE EXPLOSION SCRIPT LOADED                         █
█                                                                              █
█              WARNING: ABSOLUTE SCREEN DESTRUCTION IMMINENT                   █
█                                                                              █
████████████████████████████████████████████████████████████████████████████████

Countdown starting in 5 seconds...
Type ABORT_BOMB() to cancel!
`);

// ABORT mechanism
window.ABORT = false;
window.ABORT_BOMB = () => {
  window.ABORT = true;
  console.log("BOMB DEFUSED - CRISIS AVERTED");
};

// PURE EXPLOSION FUNCTIONS
function massiveExplosion(centerX, centerY, intensity = 1) {
  console.log("MASSIVE EXPLOSION INITIATED - INTENSITY: " + intensity);

  const explosionChars = ['█', '▓', '▒', '░', '▀', '▄', '▌', '▐', '■', '□'];
  const shockwaveChars = ['░', '▒', '▓', '█'];
  const debrisChars = ['*', '•', '°', '·', '+', 'x', 'X', '#'];

  // Initial white-hot flash
  for (let r = 0; r < 60 * intensity; r++) {
    for (let angle = 0; angle < Math.PI * 2; angle += 0.08) {
      const x = Math.round(centerX + r * Math.cos(angle));
      const y = Math.round(centerY + r * Math.sin(angle));
      setTimeout(() => {
        if (window.ABORT) return;
        writeCharAt('█', 15, x, y);
      }, r * 3);
    }
  }

  // Expanding explosion rings
  setTimeout(() => {
    for (let wave = 0; wave < 25 * intensity; wave++) {
      setTimeout(() => {
        if (window.ABORT) return;
        const radius = wave * 4;
        for (let angle = 0; angle < Math.PI * 2; angle += 0.03) {
          const x = Math.round(centerX + radius * Math.cos(angle));
          const y = Math.round(centerY + radius * Math.sin(angle));
          const char = explosionChars[Math.floor(Math.random() * explosionChars.length)];
          const color = wave < 5 ? 15 : wave < 10 ? 14 : wave < 15 ? 11 : wave < 20 ? 9 : 1;
          writeCharAt(char, color, x, y);

          // Shockwave following
          setTimeout(() => {
            if (window.ABORT) return;
            const shockChar = shockwaveChars[Math.min(3, Math.floor(wave / 6))];
            const shockColor = Math.max(0, 8 - Math.floor(wave / 4));
            writeCharAt(shockChar, shockColor, x, y);
          }, 150);

          // Debris scattered
          setTimeout(() => {
            if (window.ABORT) return;
            if (Math.random() > 0.6) {
              const debris = debrisChars[Math.floor(Math.random() * debrisChars.length)];
              writeCharAt(debris, Math.floor(Math.random() * 8), x, y);
            }
          }, 400);
        }
      }, wave * 80);
    }
  }, 300);
}

function chainExplosions() {
  console.log("CHAIN REACTION INITIATED");

  const explosionPoints = [
    [0, 0], [-30, -15], [30, 15], [-20, 20], [25, -25],
    [-35, 5], [40, -10], [10, 30], [-15, -30], [35, 35],
    [-40, -20], [20, -35], [-25, 25], [45, 0], [0, -40]
  ];

  explosionPoints.forEach((point, index) => {
    setTimeout(() => {
      if (window.ABORT) return;
      massiveExplosion(point[0], point[1], 0.8);
    }, index * 500);
  });
}

function screenSaturate() {
  console.log("SCREEN SATURATION ATTACK INITIATED");

  const chars = ['█', '▓', '▒', '░', '▀', '▄', '▌', '▐', '■', '□', '▪', '▫', '*', '+', 'x', 'X', '#'];

  for (let wave = 0; wave < 50; wave++) {
    setTimeout(() => {
      if (window.ABORT) return;

      const y = Math.floor(Math.random() * 80) - 40;
      for (let x = -60; x < 60; x++) {
        const char = chars[Math.floor(Math.random() * chars.length)];
        const color = Math.floor(Math.random() * 16);
        writeCharAt(char, color, x, y + Math.floor(Math.random() * 5) - 2);
      }
    }, wave * 100);
  }
}

function plasmaBurst(centerX, centerY) {
  console.log("PLASMA BURST ACTIVATED");

  let phase = 0;
  const plasmaInterval = setInterval(() => {
    if (window.ABORT) { clearInterval(plasmaInterval); return; }

    for (let r = 1; r < 35; r++) {
      for (let angle = 0; angle < Math.PI * 2; angle += 0.1) {
        const x = Math.round(centerX + r * Math.cos(angle + phase * 0.1));
        const y = Math.round(centerY + r * Math.sin(angle + phase * 0.1) * 0.6);

        const intensity = Math.sin(r * 0.2 + phase * 0.3) + 1;
        const char = intensity > 1.5 ? '█' : intensity > 1.2 ? '▓' : intensity > 0.8 ? '▒' : '░';
        const color = intensity > 1.7 ? 15 : intensity > 1.4 ? 14 : intensity > 1.1 ? 11 : intensity > 0.8 ? 9 : 8;

        writeCharAt(char, color, x, y);
      }
    }
    phase++;

    if (phase > 80) clearInterval(plasmaInterval);
  }, 60);
}

function staticStorm() {
  console.log("STATIC STORM ENGAGED");

  const staticChars = ['█', '▓', '▒', '░', '▀', '▄', '▌', '▐'];

  for (let burst = 0; burst < 40; burst++) {
    setTimeout(() => {
      if (window.ABORT) return;

      const centerX = Math.floor(Math.random() * 80) - 40;
      const centerY = Math.floor(Math.random() * 40) - 20;

      for (let i = 0; i < 200; i++) {
        const x = centerX + Math.floor(Math.random() * 20) - 10;
        const y = centerY + Math.floor(Math.random() * 10) - 5;
        const char = staticChars[Math.floor(Math.random() * staticChars.length)];
        const color = Math.random() > 0.7 ? 15 : Math.floor(Math.random() * 8);

        setTimeout(() => {
          if (window.ABORT) return;
          writeCharAt(char, color, x, y);
        }, i * 5);
      }
    }, burst * 200);
  }
}

function THE_SINGULARITY(centerX, centerY) {
  console.log("THE SINGULARITY HAS FORMED - REALITY IS COLLAPSING");

  let singularityPhase = 0;
  const event_horizon = [];

  // Initialize event horizon
  for (let angle = 0; angle < Math.PI * 2; angle += 0.05) {
    event_horizon.push({
      angle: angle,
      radius: 50,
      char: '█',
      color: 0
    });
  }

  const singularityInterval = setInterval(() => {
    if (window.ABORT) { clearInterval(singularityInterval); return; }

    // Update event horizon - everything gets pulled in
    event_horizon.forEach(point => {
      point.radius = Math.max(0.1, point.radius - 0.3);
      point.angle += 0.02 * (51 - point.radius) * 0.1;

      const x = Math.round(centerX + point.radius * Math.cos(point.angle));
      const y = Math.round(centerY + point.radius * Math.sin(point.angle) * 0.7);

      // Intensity increases as it approaches singularity
      const intensity = (51 - point.radius) / 50;
      if (intensity > 0.9) {
        point.char = '█';
        point.color = 15;
      } else if (intensity > 0.7) {
        point.char = '▓';
        point.color = 14;
      } else if (intensity > 0.5) {
        point.char = '▒';
        point.color = 11;
      } else if (intensity > 0.3) {
        point.char = '░';
        point.color = 8;
      } else {
        point.char = '·';
        point.color = 7;
      }

      writeCharAt(point.char, point.color, x, y);
    });

    // Singularity core pulsing
    const coreSize = Math.floor(2 + Math.sin(singularityPhase * 0.3) * 1);
    for (let dx = -coreSize; dx <= coreSize; dx++) {
      for (let dy = -coreSize; dy <= coreSize; dy++) {
        if (dx * dx + dy * dy <= coreSize * coreSize) {
          writeCharAt('█', 0, centerX + dx, centerY + dy);
        }
      }
    }

    singularityPhase++;

    if (singularityPhase > 200) {
      // Singularity collapse
      for (let r = 0; r < 80; r++) {
        setTimeout(() => {
          if (window.ABORT) return;
          for (let angle = 0; angle < Math.PI * 2; angle += 0.1) {
            const x = Math.round(centerX + r * Math.cos(angle));
            const y = Math.round(centerY + r * Math.sin(angle) * 0.6);
            writeCharAt(' ', 0, x, y);
          }
        }, r * 20);
      }
      clearInterval(singularityInterval);
    }
  }, 80);
}

// THE ULTIMATE DESTRUCTION SEQUENCE
function DETONATE_PURE_BOMB() {
  if (window.ABORT) return;

  console.log("DETONATION SEQUENCE INITIATED - PURE DESTRUCTION MODE");

  // Phase 1: Initial massive explosions
  setTimeout(() => massiveExplosion(0, 0, 1.5), 1000);
  setTimeout(() => massiveExplosion(-25, -12, 1.2), 1800);
  setTimeout(() => massiveExplosion(25, 12, 1.2), 2200);
  setTimeout(() => massiveExplosion(0, -25, 1.0), 2600);
  setTimeout(() => massiveExplosion(0, 25, 1.0), 3000);

  // Phase 2: Chain reaction
  setTimeout(() => chainExplosions(), 4000);

  // Phase 3: Plasma bursts
  setTimeout(() => plasmaBurst(-20, 0), 8000);
  setTimeout(() => plasmaBurst(20, 0), 9000);
  setTimeout(() => plasmaBurst(0, 20), 10000);
  setTimeout(() => plasmaBurst(0, -20), 11000);

  // Phase 4: Screen saturation
  setTimeout(() => screenSaturate(), 13000);

  // Phase 5: Static storm
  setTimeout(() => staticStorm(), 18000);

  // Phase 6: THE SINGULARITY FORMS
  setTimeout(() => THE_SINGULARITY(0, 0), 25000);

  // Final message
  setTimeout(() => {
    if (window.ABORT) return;
    console.log(`
████████████████████████████████████████████████████████████████████████████████
█                                                                              █
█                         PURE DESTRUCTION COMPLETE                           █
█                                                                              █
█                    THE SINGULARITY HAS CONSUMED ALL                         █
█                                                                              █
█                         SCREEN OBLITERATED                                  █
█                                                                              █
████████████████████████████████████████████████████████████████████████████████
    `);
  }, 45000);
}

// Countdown with abort option
let countdown = 5;
const countdownInterval = setInterval(() => {
  if (window.ABORT) {
    clearInterval(countdownInterval);
    console.log("BOMB SUCCESSFULLY DEFUSED - SINGULARITY AVERTED");
    return;
  }

  if (countdown > 0) {
    console.log(`DETONATING IN ${countdown}... (type ABORT_BOMB() to stop!)`);
    countdown--;
  } else {
    clearInterval(countdownInterval);
    console.log("DETONATION COMMENCED");
    DETONATE_PURE_BOMB();
  }
}, 1000);

// Global abort function
window.ABORT_BOMB = () => {
  window.ABORT = true;
  clearInterval(countdownInterval);
  console.log(`
████████████████████████████████████████████████████████████████████████████████
█                                                                              █
█                            BOMB DEFUSED                                     █
█                                                                              █
█                    Crisis averted - Screen is safe                          █
█                    The Singularity has been contained                       █
█                                                                              █
████████████████████████████████████████████████████████████████████████████████
  `);
};