Zombie Rush: Script

🧟 Zombie Rush – Survival Game

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
    <title>Zombie Rush - Survive the Horde</title>
    <style>
        * 
            user-select: none;
            -webkit-tap-highlight-color: transparent;
    body 
        margin: 0;
        min-height: 100vh;
        background: linear-gradient(145deg, #0a1f0a 0%, #030803 100%);
        display: flex;
        justify-content: center;
        align-items: center;
        font-family: 'Courier New', 'VT323', monospace;
        touch-action: manipulation;
.game-container 
        padding: 20px;
canvas 
        display: block;
        margin: 0 auto;
        box-shadow: 0 20px 35px rgba(0,0,0,0.5), 0 0 0 4px #5a3e1f, 0 0 0 8px #2c1e0e;
        border-radius: 12px;
        cursor: crosshair;
        background: #1a2a1a;
.ui-bar 
        display: flex;
        justify-content: space-between;
        align-items: baseline;
        background: #000000aa;
        backdrop-filter: blur(4px);
        padding: 10px 20px;
        border-radius: 60px;
        margin-bottom: 15px;
        color: #b3ffb3;
        text-shadow: 0 0 5px #00aa00;
        font-weight: bold;
        font-size: 1.5rem;
        gap: 20px;
        flex-wrap: wrap;
.stats span 
        color: #ffd966;
        font-size: 2rem;
        margin-left: 8px;
        background: #1e2a1e;
        padding: 0 12px;
        border-radius: 30px;
button 
        background: #3c2a1f;
        border: none;
        font-family: inherit;
        font-weight: bold;
        font-size: 1.2rem;
        padding: 6px 18px;
        border-radius: 60px;
        color: #ffecb3;
        cursor: pointer;
        box-shadow: 0 3px 0 #1f140a;
        transition: 0.07s linear;
button:active 
        transform: translateY(2px);
        box-shadow: 0 1px 0 #1f140a;
.controls-tip 
        font-size: 0.8rem;
        background: #00000099;
        padding: 6px 14px;
        border-radius: 28px;
        letter-spacing: 1px;
@media (max-width: 800px) 
        .ui-bar  font-size: 1rem; 
        .stats span  font-size: 1.4rem; 
        .controls-tip  font-size: 0.65rem;
</style>

</head> <body> <div> <div class="game-container"> <div class="ui-bar"> <div class="stats">πŸ’€ SCORE: <span id="scoreValue">0</span></div> <div class="stats">🧠 WAVE: <span id="waveValue">1</span></div> <div class="stats">❀️ <span id="healthValue">100</span>%</div> <button id="resetBtn">πŸ”„ RESTART</button> </div> <canvas id="gameCanvas" width="1000" height="600"></canvas> <div class="ui-bar" style="justify-content: center; margin-top: 12px;"> <div class="controls-tip">🎯 MOUSE / FINGER β†’ AIM & SHOOT</div> <div class="controls-tip">πŸ’₯ CLICK/TAP = BANG! (AMMO INFINITE)</div> </div> </div> </div>

<script> (function() // ----- CANVAS ----- const canvas = document.getElementById('gameCanvas'); const ctx = canvas.getContext('2d');

    // ----- GAME DIMENSIONS -----
    const W = 1000, H = 600;
// ----- PLAYER -----
    let player = 
        x: W/2,
        y: H/2,
        radius: 18,
        health: 100,
        maxHealth: 100
    ;
// ----- ZOMBIES -----
    let zombies = [];
// ----- BULLETS -----
    let bullets = [];
// ----- EFFECTS (blood splats & hit flashes)-----
    let bloodEffects = [];   // x, y, life
    let zombieHitFlash = []; // store zombie index + timer
// ----- GAME STATE -----
    let score = 0;
    let wave = 1;
    let zombiesToSpawn = 6;    // initial wave count
    let waveInProgress = true;
    let gameOver = false;
    let frame = 0;
// ----- SPAWN TIMER (to avoid massive instant wave)-----
    let spawnCooldown = 0;
// ----- AIM (mouse/touch)-----
    let aimX = player.x, aimY = player.y;
    let mouseInside = true;
// ----- PERFORMANCE / SHOT DELAY (semi-auto)-----
    let shotDelay = 0;
    const SHOT_COOLDOWN_FRAMES = 8;   // ~130ms at 60fps
// ----- HELPER FUNCTIONS -----
    function clamp(value, min, max)
        return Math.min(max, Math.max(min, value));
// reset full game
    function resetGame()
        gameOver = false;
        score = 0;
        wave = 1;
        waveInProgress = true;
        player.health = player.maxHealth;
        player.x = W/2;
        player.y = H/2;
        zombies = [];
        bullets = [];
        bloodEffects = [];
        zombieHitFlash = [];
        frame = 0;
        spawnCooldown = 0;
        shotDelay = 0;
// initial wave config
        zombiesToSpawn = getWaveZombieCount(wave);
        spawnRemainingZombies();
updateUI();
// how many zombies for current wave
    function getWaveZombieCount(waveNum)
        return Math.min(5 + Math.floor(waveNum * 1.4), 45);
// spawn zombies gradually (up to zombiesToSpawn)
    function spawnRemainingZombies()
        if(gameOver) return;
        let needed = zombiesToSpawn - zombies.length;
        if(needed <= 0) return;
        let spawnNow = Math.min(needed, 2); // smooth spawn rate
        for(let i=0; i<spawnNow; i++)
            spawnOneZombie();
function spawnOneZombie()
        // pick edge of canvas
        let side = Math.floor(Math.random() * 4); // 0:left,1:right,2:top,3:bottom
        let x, y;
        const padding = 25;
        if(side === 0) // left
            x = -padding;
            y = Math.random() * H;
         else if(side === 1) // right
            x = W + padding;
            y = Math.random() * H;
         else if(side === 2) // top
            x = Math.random() * W;
            y = -padding;
         else  // bottom
            x = Math.random() * W;
            y = H + padding;
// zombie speed scales with wave (but capped)
        let baseSpeed = 0.9 + wave * 0.12;
        let speed = Math.min(baseSpeed, 3.8);
        // health scaling
        let health = 1 + Math.floor(wave / 4);
        health = Math.min(health, 5);
zombies.push(
            x: x, y: y,
            radius: 16,
            health: health,
            maxHealth: health,
            speed: speed,
            color: `hsl($30 + Math.random() * 20, 70%, 35%)`
        );
// update wave logic (check if wave completed)
    function updateWaveProgress()
        if(gameOver) return;
        if(waveInProgress && zombies.length === 0 && zombiesToSpawn === 0)
            // wave cleared!
            wave++;
            waveInProgress = true;
            // reward health
            let healAmount = 15;
            player.health = Math.min(player.maxHealth, player.health + healAmount);
            // set new wave zombie count
            zombiesToSpawn = getWaveZombieCount(wave);
            // small dramatic spawn pause
            spawnCooldown = 12;
            // add score bonus
            score += wave * 5;
            updateUI();
            // start spawning again (next frames)
else if(zombies.length === 0 && zombiesToSpawn > 0 && !gameOver)
            // still need to spawn more this wave
            if(spawnCooldown <= 0)
                spawnRemainingZombies();
                spawnCooldown = 6;
// bullet vs zombie collision & damage
    function handleShooting()
        for(let i=bullets.length-1; i>=0; i--)
            let b = bullets[i];
            let bulletHit = false;
            for(let j=0; j<zombies.length; j++)
                let z = zombies[j];
                const dx = b.x - z.x;
                const dy = b.y - z.y;
                const dist = Math.hypot(dx, dy);
                if(dist < b.radius + z.radius)
                    // HIT!
                    bulletHit = true;
                    z.health -= 1;
                    // blood effect at hit point
                    bloodEffects.push( x: b.x, y: b.y, life: 8 );
                    // hit flash marker
                    zombieHitFlash.push( idx: j, timer: 4 );
if(z.health <= 0)
                        // zombie killed
                        const idxDead = zombies.indexOf(z);
                        if(idxDead !== -1) zombies.splice(idxDead,1);
                        score += 10 + Math.floor(wave/2);
                        updateUI();
break; // bullet hits only one zombie
if(bulletHit)
                bullets.splice(i,1);
             else 
                // move bullet
                b.x += b.vx;
                b.y += b.vy;
                // remove if outside canvas with margin
                if(b.x < -50
// move zombies toward player & collision damage
    function updateZombies()
        for(let i=0; i<zombies.length; i++)
            let z = zombies[i];
            const dx = player.x - z.x;
            const dy = player.y - z.y;
            const len = Math.hypot(dx, dy);
            if(len > 0.01)
                let move = Math.min(z.speed, len - (player.radius + z.radius - 2));
                if(move > 0)
                    let stepX = (dx / len) * Math.min(z.speed, move);
                    let stepY = (dy / len) * Math.min(z.speed, move);
                    z.x += stepX;
                    z.y += stepY;
// collision with player (damage)
            const distToPlayer = Math.hypot(player.x - z.x, player.y - z.y);
            if(distToPlayer < player.radius + z.radius && !gameOver)
                // zombie hurts player
                let dmg = Math.max(5, 8 - Math.floor(wave/6));
                dmg = Math.min(dmg, 18);
                player.health = Math.max(0, player.health - dmg);
                updateUI();
                // knockback zombie away slightly to avoid multi-hit same frame
                const angle = Math.atan2(z.y - player.y, z.x - player.x);
                const push = 28;
                z.x += Math.cos(angle) * push;
                z.y += Math.sin(angle) * push;
                // blood at player
                bloodEffects.push( x: player.x, y: player.y, life: 12 );
if(player.health <= 0)
                    gameOver = true;
                    player.health = 0;
// aim at cursor / touch
    function updateAim(e)
        const rect = canvas.getBoundingClientRect();
        const scaleX = canvas.width / rect.width;
        const scaleY = canvas.height / rect.height;
        let clientX, clientY;
        if(e.touches)
            clientX = e.touches[0].clientX;
            clientY = e.touches[0].clientY;
            e.preventDefault();
         else 
            clientX = e.clientX;
            clientY = e.clientY;
let canvasX = (clientX - rect.left) * scaleX;
        let canvasY = (clientY - rect.top) * scaleY;
        aimX = clamp(canvasX, 0, W);
        aimY = clamp(canvasY, 0, H);
function shootFromPlayer()
        if(gameOver) return;
        if(shotDelay > 0) return;
        // direction from player to aim point
        let dx = aimX - player.x;
        let dy = aimY - player.y;
        const length = Math.hypot(dx, dy);
        if(length < 0.001) return;
        let normX = dx / length;
        let normY = dy / length;
        const bulletSpeed = 12;
        bullets.push(
            x: player.x + normX * (player.radius+4),
            y: player.y + normY * (player.radius+4),
            vx: normX * bulletSpeed,
            vy: normY * bulletSpeed,
            radius: 5,
            life: 1
        );
        shotDelay = SHOT_COOLDOWN_FRAMES;
        // muzzle flash tiny effect
        bloodEffects.push( x: player.x + normX*12, y: player.y + normY*12, life: 3 );
// update UI elements
    function updateUI()
        document.getElementById('scoreValue').innerText = Math.floor(score);
        document.getElementById('waveValue').innerText = wave;
        document.getElementById('healthValue').innerText = Math.max(0, Math.floor(player.health));
// update timers, effects, delays
    function updateTimersAndEffects()
        if(shotDelay > 0) shotDelay--;
        if(spawnCooldown > 0) spawnCooldown--;
// blood effect fade
        for(let i=0; i<bloodEffects.length; i++)
            bloodEffects[i].life--;
            if(bloodEffects[i].life <= 0)
                bloodEffects.splice(i,1);
                i--;
// zombie hit flash removal
        for(let i=0; i<zombieHitFlash.length; i++)
            zombieHitFlash[i].timer--;
            if(zombieHitFlash[i].timer <= 0)
                zombieHitFlash.splice(i,1);
                i--;
// keep player inside arena (with margin)
    function clampPlayer()
        player.x = clamp(player.x, player.radius+2, W - player.radius-2);
        player.y = clamp(player.y, player.radius+2, H - player.radius-2);
// Game Loop update logic
    function updateGame()
        if(gameOver) return;
clampPlayer();
        updateZombies();
        handleShooting();
// spawning logic for wave
        if(waveInProgress)
            if(zombies.length === 0 && zombiesToSpawn === 0)
                waveInProgress = false;
                updateWaveProgress();
             else 
                if(spawnCooldown <= 0 && zombies.length + (zombiesToSpawn - zombies.length) > 0)
                    spawnRemainingZombies();
                    spawnCooldown = 7;
else 
            updateWaveProgress();
updateTimersAndEffects();
// if game over due to health
        if(player.health <= 0)
            gameOver = true;
            player.health = 0;
// ------------------- DRAW EVERYTHING ------------------
    function draw()
        ctx.clearRect(0, 0, W, H);
// ground texture (rough)
        ctx.fillStyle = "#2c402c";
        ctx.fillRect(0,0,W,H);
        for(let i=0;i<300;i++)
            ctx.fillStyle = `rgba(70,50,20,0.15)`;
            ctx.beginPath();
            ctx.arc((i*131)%W, (i*73)%H, 2, 0, Math.PI*2);
            ctx.fill();
// ----- BLOOD EFFECTS -----
        for(let b of bloodEffects)
            ctx.beginPath();
            ctx.arc(b.x, b.y, 6, 0, Math.PI*2);
            ctx.fillStyle = `rgba(140, 20, 10, $Math.min(0.7, b.life/7))`;
            ctx.fill();
            ctx.beginPath();
            ctx.arc(b.x-2, b.y-1, 3, 0, Math.PI*2);
            ctx.fillStyle = `rgba(180, 30, 10, 0.6)`;
            ctx.fill();
// ----- ZOMBIES (with flash on hit)-----
        for(let i=0; i<zombies.length; i++) "#4f6b2f";
            ctx.fill();
            ctx.fillStyle = "#2a2418";
            ctx.beginPath();
            ctx.ellipse(z.x-4, z.y-3, 3, 4, 0, 0, Math.PI*2);
            ctx.fill();
            ctx.beginPath();
            ctx.ellipse(z.x+4, z.y-3, 3, 4, 0, 0, Math.PI*2);
            ctx.fill();
            // red eyes
            ctx.fillStyle = "#ff3333";
            ctx.beginPath();
            ctx.arc(z.x-4, z.y-4, 2, 0, Math.PI*2);
            ctx.fill();
            ctx.beginPath();
            ctx.arc(z.x+4, z.y-4, 2, 0, Math.PI*2);
            ctx.fill();
            // mouth
            ctx.beginPath();
            ctx.strokeStyle = "#2e1c0c";
            ctx.lineWidth = 2;
            ctx.arc(z.x, z.y+2, 7, 0.1, Math.PI - 0.1);
            ctx.stroke();
            // health bar
            let healthPercent = z.health / z.maxHealth;
            ctx.fillStyle = "#631010";
            ctx.fillRect(z.x-12, z.y-14, 24, 5);
            ctx.fillStyle = "#88ff88";
            ctx.fillRect(z.x-12, z.y-14, 24 * healthPercent, 4);
// ----- BULLETS (hot tracer)-----
        for(let b of bullets)
            ctx.beginPath();
            ctx.arc(b.x, b.y, 5, 0, Math.PI*2);
            ctx.fillStyle = "#ffcc44";
            ctx.fill();
            ctx.beginPath();
            ctx.arc(b.x, b.y, 2, 0, Math.PI*2);
            ctx.fillStyle = "#ff8822";
            ctx.fill();
// ----- PLAYER (survivor)-----
        ctx.shadowBlur = 0;
        ctx.beginPath();
        ctx.arc(player.x, player.y, player.radius, 0, Math.PI*2);
        ctx.fillStyle = "#7c9f6e";
        ctx.fill();
        ctx.strokeStyle = "#2d4a1e";
        ctx.lineWidth = 2;
        ctx.stroke();
        // eyes
        ctx.fillStyle = "#f5f2e0";
        ctx.beginPath();
        ctx.arc(player.x-6, player.y-4, 4, 0, Math.PI*2);
        ctx.fill();
        ctx.beginPath();
        ctx.arc(player.x+6, player.y-4, 4, 0, Math.PI*2);
        ctx.fill();
        ctx.fillStyle = "#2f2819";
        ctx.beginPath();
        ctx.arc(player.x-6, player.y-5, 2, 0, Math.PI*2);
        ctx.fill();
        ctx.beginPath();
        ctx.arc(player.x+6, player.y-5, 2, 0, Math.PI*2);
        ctx.fill();
        // mouth (determined)
        ctx.beginPath();
        ctx.arc(player.x, player.y+4, 6, 0.05, Math.PI - 0.05);
        ctx.stroke();
        // crosshair (aim)
        ctx.beginPath();
        ctx.moveTo(aimX-12, aimY);
        ctx.lineTo(aimX-5, aimY);
        ctx.moveTo(aimX+5, aimY);
        ctx.lineTo(aimX+12, aimY);
        ctx.moveTo(aimX, aimY-12);
        ctx.lineTo(aimX, aimY-5);
        ctx.moveTo(aimX, aimY+5);
        ctx.lineTo(aimX, aimY+12);
        ctx.strokeStyle = "#fffcdd";
        ctx.lineWidth = 2;
        ctx.stroke();
        ctx.beginPath();
        ctx.arc(aimX, aimY, 7, 0, Math.PI*2);
        ctx.strokeStyle = "#ffbb99";
        ctx.stroke();
// health overlay if game over
        if(gameOver)
            ctx.font = "bold 38px 'Courier New'";
            ctx.fillStyle = "#ff3333aa";
            ctx.shadowBlur = 0;
            ctx.fillText("☠ GAME OVER ☠", W/2-150, H/2-40);
            ctx.font = "20px monospace";
            ctx.fillStyle = "#dddd99";
            ctx.fillText("click RESTART", W/2-65, H/2+30);
// wave info text
        if(!gameOver && zombies.length === 0 && zombiesToSpawn === 0 && !waveInProgress)
            ctx.font = "bold 26 monospace";
            ctx.fillStyle = "#c9ffb0";
            ctx.shadowBlur = 2;
            ctx.fillText(`WAVE $wave INCOMING...`, W/2-130, 70);
// ----- MAIN GAME LOOP -----
    function gameLoop()
        if(!gameOver)
            updateGame();
draw();
        requestAnimationFrame(gameLoop);
// ----- EVENT HANDLERS -----
    function initEvents()
        // mouse movement
        canvas.addEventListener('mousemove', (e) => 
            updateAim(e);
            mouseInside = true;
        );
        canvas.addEventListener('mouseleave', () => 
            // keep last aim but no big deal
        );
        canvas.addEventListener('click', (e) => 
            e.preventDefault();
            if(gameOver) return;
            updateAim(e);
            shootFromPlayer();
        );
        // touch events for mobile
        canvas.addEventListener('touchstart', (e) => 
            e.preventDefault();
            updateAim(e);
            shootFromPlayer();
        );
        canvas.addEventListener('touchmove', (e) => 
            e.preventDefault();
            updateAim(e);
        );
        document.getElementById('resetBtn').addEventListener('click', () => 
            resetGame();
        );
// initial reset & start
    resetGame();
    initEvents();
    gameLoop();
)();

</script> </body> </html>

Scripting Your Own Code (The Legit Way)

Did you know you can actually learn to script by playing games like Zombie Rush? zombie rush script

If you are interested in how these exploits work, you should try learning Lua on Roblox Studio. Instead of breaking a game, try building your own!

Part 7: The Future of Zombie Rush Scripts (AI Integration)

As we look toward 2025 and beyond, the "Zombie Rush Script" is evolving. Static auto-clickers are dying. AI-powered scripts are rising. 🧟 Zombie Rush – Survival Game &lt;

The Gameplay Definition

In many survival games, a "Zombie Rush" refers to a specific wave mechanic where a massive, unrelenting horde of zombies charges the player. A "script" in this context is a pre-written plan or walkthroughβ€”a set of instructions on where to stand, what weapons to buy, and when to run to survive a "Rush" wave.

However, in modern gaming jargon, the word "script" usually implies automation. &lt;/script&gt; &lt;/body&gt; &lt;/html&gt;

Areas for Improvement