

<!--https://7some.netlify.app-->
<!--https://7some.netlify.app-->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>7some | Credits</title>
    <style>
        html, body { height: 100%; margin: 0; background: #000; }
        body { display: flex; flex-direction: column; min-height: 100vh; color: #fff; }
        header { width: 100%; text-align: center; padding: 1rem 0; position: relative; }
        header h1 { color: #fff; font-weight: 700; margin: 0; font-size: 2rem; font-family: Arial, Helvetica, sans-serif; }
        .panic-btn {
            position: absolute;
            top: 1rem;
            right: 1rem;
            color: #fff;
            background: transparent;
            border: 2px solid #fff;
            padding: 0.75rem 1rem;
            font-size: 1rem;
            border-radius: 8px;
            cursor: pointer;
            font-family: inherit;
        }
        .panic-btn:hover { background: rgba(255,255,255,0.08); }
        .back-btn {
            position: absolute;
            top: 1rem;
            left: 1rem;
            color: #fff;
            background: transparent;
            border: 2px solid #fff;
            padding: 0.75rem 1rem;
            font-size: 0.95rem;
            border-radius: 8px;
            text-decoration: none;
            display: inline-flex;
            align-items: center;
        }
        .back-btn:hover { background: rgba(255,255,255,0.08); }
        main { flex: 1; display: flex; align-items: flex-start; justify-content: center; padding-top: 30vh; }
        .buttons { display: flex; gap: 1.25rem; flex-wrap: wrap; justify-content: center; }
        .btn {
            color: #fff;
            background: transparent;
            border: 2px solid #fff;
            padding: 1rem 1.5rem;
            font-size: 1.125rem;
            border-radius: 8px;
            cursor: pointer;
            font-family: inherit;
        }
        .btn:hover { background: rgba(255,255,255,0.08); }
    *{
        box-sizing:border-box;
    }

    body{
        margin:0;
        background:#111;
        background-image: repeating-linear-gradient(
            to bottom,
            transparent 0,
            transparent 5px,
            rgba(0,0,0,0.85) 5px,
            rgba(0,0,0,0.85) 6px
        );
        background-size: 100% 6px;
        animation: scroll-stripes 0.625s linear infinite;
        display:flex;
        justify-content:center;
        align-items:center;
        height:100vh;
        font-family:Arial,sans-serif;
        overflow:hidden;
        position:relative;
    }

    #bg-canvas {
        position:fixed;
        inset:0;
        width:100%;
        height:100%;
        z-index:0;
        pointer-events:none;
    }

    body::before {
        content: "";
        position: fixed;
        inset: 0;
        pointer-events: none;
        background-image:
            repeating-linear-gradient(90deg, transparent 0 50px, transparent 50px 54px, rgba(0,0,0,0.85) 54px 56px, transparent 56px 100%),
            repeating-linear-gradient(transparent 0 50px, transparent 50px 54px, rgba(0,0,0,0.85) 54px 56px, transparent 56px 100%);
        background-size: 120px 120px;
        background-blend-mode: multiply;
        opacity: 0.45;
        animation: scroll-squares 0.625s linear infinite;
    }

    @keyframes scroll-stripes {
        from { background-position: 0 0; }
        to { background-position: 0 -6px; }
    }

    @keyframes scroll-squares {
        from { background-position: 0 0; }
        to { background-position: -24px -24px; }
    }

    header, main, .buttons { position: relative; z-index: 1; }

    </style>
</head>
<body>
    <canvas id="bg-canvas"></canvas>
    <div class="left-credits" style="position:fixed; left:0; top:50%; transform:translateY(-50%); padding-left:8px; color:#fff; font-weight:600; font-size:1.5rem; z-index:2; text-align:left;">
        <div style="margin-bottom:0.35rem;">Made by .n777q</div>
        <hr>
        <div><a href="https://discord.gg/jKj9DSjT3E" target="_blank" rel="noopener noreferrer" style="color:#66a3ff; text-decoration:none;">Discord Server</a></div>
    </div>
    <header>
        <button type="button" class="panic-btn" onclick="window.location.href='https://google.com'">Panic</button>
        <a aria-label='Back to home' class='back-btn' href='/'>Back</a>
        <h1>7some</h1>
    </header>
    <main>
    </main>
<script>

(function(){
const canvas = document.getElementById("bg-canvas");
if (!canvas) return;
const ctx = canvas.getContext("2d");
const searchEl = document.getElementById("search");
const goBtn = document.querySelector("button[onclick=\"go()\"]");

const triangles = [];
const squares = [];
const TRIANGLE_COUNT = 10;
const MIN_SPEED = 1.4;
const MAX_SPEED = 2.6;

const SQUARE_COUNT = 5;
const SQUARE_MIN_SPEED = 0.5;
const SQUARE_MAX_SPEED = 1.0;

function clamp(value, min, max) { return Math.min(Math.max(value, min), max); }

function resizeCanvas() {
    canvas.width = window.innerWidth;
    canvas.height = window.innerHeight;
}

function createTriangles() {
    triangles.length = 0;
    for (let i = 0; i < TRIANGLE_COUNT; i++) {
        const size = 8 + Math.random() * 8;
        const angle = Math.random() * Math.PI * 2;
        const speed = MIN_SPEED + Math.random() * (MAX_SPEED - MIN_SPEED);
        triangles.push({
            x: Math.random() * window.innerWidth,
            y: Math.random() * window.innerHeight,
            dx: Math.cos(angle) * speed,
            dy: Math.sin(angle) * speed,
            size,
            type: 'triangle'
        });
    }
}

function createSquares() {
    squares.length = 0;
    for (let i = 0; i < SQUARE_COUNT; i++) {
        const side = 18 + Math.random() * 28;
        const radius = Math.hypot(side / 2, side / 2);
        const angle = Math.random() * Math.PI * 2;
        const speed = SQUARE_MIN_SPEED + Math.random() * (SQUARE_MAX_SPEED - SQUARE_MIN_SPEED);
        const baseRot = Math.random() * Math.PI * 2;
        const rotSign = Math.random() < 0.5 ? -1 : 1;
        const rotSpeed = rotSign * (0.004 + Math.random() * 0.012);

        let dx = Math.cos(angle) * speed;
        let dy = Math.sin(angle) * speed;
        if (Math.abs(dx) < 0.02) dx = Math.sign(dx || 1) * 0.02;
        if (Math.abs(dy) < 0.02) dy = Math.sign(dy || 1) * 0.02;

        squares.push({
            x: Math.random() * window.innerWidth,
            y: Math.random() * window.innerHeight,
            dx,
            dy,
            size: radius,
            side: side,
            rot: baseRot,
            rotSpeed: rotSpeed,
            type: 'square'
        });
    }
}

function getObstacles() {
    const obstacles = [];
    [searchEl, goBtn].forEach((el) => {
        if (!el) return;
        const rect = el.getBoundingClientRect();
        if (rect.width > 0 && rect.height > 0) {
            obstacles.push(rect);
        }
    });
    return obstacles;
}

function reflectVelocity(velocity, normal) {
    const dot = velocity.dx * normal.x + velocity.dy * normal.y;
    return { dx: velocity.dx - 2 * dot * normal.x, dy: velocity.dy - 2 * dot * normal.y };
}

function drawTriangle(triangle) {
    ctx.save();
    ctx.translate(triangle.x, triangle.y);
    const angle = Math.atan2(triangle.dy, triangle.dx);
    ctx.rotate(angle);
    ctx.beginPath();
    ctx.moveTo(triangle.size, 0);
    ctx.lineTo(-triangle.size * 0.6, triangle.size * 0.6);
    ctx.lineTo(-triangle.size * 0.6, -triangle.size * 0.6);
    ctx.closePath();
    ctx.fillStyle = "rgba(0,0,0,0.96)";
    ctx.fill();
    ctx.restore();
}

function drawSquare(sq) {
    ctx.save();
    ctx.translate(sq.x, sq.y);
    ctx.rotate(sq.rot);
    const half = sq.side / 2;
    ctx.fillStyle = "rgba(0,0,0,0.92)";
    ctx.fillRect(-half, -half, sq.side, sq.side);
    ctx.restore();
}

function handleObstacleCollision(entity, rect) {
    const closestX = clamp(entity.x, rect.left, rect.right);
    const closestY = clamp(entity.y, rect.top, rect.bottom);
    const dx = entity.x - closestX;
    const dy = entity.y - closestY;
    const distance = Math.hypot(dx, dy);
    const radius = (entity.size || 10) * 0.9;

    if (distance < radius && distance > 0) {
        const normal = { x: dx / distance, y: dy / distance };
        const overlap = radius - distance + 1;
        entity.x += normal.x * overlap;
        entity.y += normal.y * overlap;
        const reflected = reflectVelocity(entity, normal);
        entity.dx = reflected.dx;
        entity.dy = reflected.dy;
    } else if (distance === 0) {
        entity.dx = -entity.dx;
        entity.dy = -entity.dy;
    }
}

function handleEntityCollisions() {
    const entities = triangles.concat(squares);
    const len = entities.length;

    for (let i = 0; i < len; i++) {
        for (let j = i + 1; j < len; j++) {
            const a = entities[i];
            const b = entities[j];
            const dx = b.x - a.x;
            const dy = b.y - a.y;
            let dist = Math.hypot(dx, dy);
            const rA = a.size;
            const rB = b.size;
            const minDist = rA + rB;

            if (dist === 0) {
                const angle = Math.random() * Math.PI * 2;
                a.x += Math.cos(angle) * 0.5;
                a.y += Math.sin(angle) * 0.5;
                dist = 0.5;
            }

            if (dist < minDist) {
                const mA = Math.max(1, rA * rA);
                const mB = Math.max(1, rB * rB);
                const overlap = minDist - dist + 0.5;
                const nx = dx / dist;
                const ny = dy / dist;
                const total = mA + mB;
                a.x -= nx * (overlap * (mB / total));
                a.y -= ny * (overlap * (mB / total));
                b.x += nx * (overlap * (mA / total));
                b.y += ny * (overlap * (mA / total));

                const rvx = a.dx - b.dx;
                const rvy = a.dy - b.dy;
                const relVel = rvx * nx + rvy * ny;

                if (relVel < 0) {
                    const e = 0.9;
                    const j = -(1 + e) * relVel / (1 / mA + 1 / mB);
                    const jx = j * nx;
                    const jy = j * ny;
                    a.dx += (jx / mA);
                    a.dy += (jy / mA);
                    b.dx -= (jx / mB);
                    b.dy -= (jy / mB);
                }
            }
        }
    }
}

let lastTime = performance.now();
function animate(time) {
    const dt = Math.min((time - lastTime) / 16.67, 2);
    lastTime = time;

    ctx.clearRect(0, 0, canvas.width, canvas.height);
    const obstacles = getObstacles();

    triangles.forEach((triangle) => {
        triangle.x += triangle.dx * dt;
        triangle.y += triangle.dy * dt;

        if (triangle.x - triangle.size < 0) {
            triangle.x = triangle.size;
            triangle.dx = Math.abs(triangle.dx);
        } else if (triangle.x + triangle.size > canvas.width) {
            triangle.x = canvas.width - triangle.size;
            triangle.dx = -Math.abs(triangle.dx);
        }

        if (triangle.y - triangle.size < 0) {
            triangle.y = triangle.size;
            triangle.dy = Math.abs(triangle.dy);
        } else if (triangle.y + triangle.size > canvas.height) {
            triangle.y = canvas.height - triangle.size;
            triangle.dy = -Math.abs(triangle.dy);
        }

        obstacles.forEach((rect) => handleObstacleCollision(triangle, rect));
    });

    squares.forEach((sq) => {
        sq.x += sq.dx * dt;
        sq.y += sq.dy * dt;
        sq.rot += sq.rotSpeed * dt;

        if (sq.x - sq.size < 0) {
            sq.x = sq.size;
            sq.dx = Math.abs(sq.dx);
        } else if (sq.x + sq.size > canvas.width) {
            sq.x = canvas.width - sq.size;
            sq.dx = -Math.abs(sq.dx);
        }

        if (sq.y - sq.size < 0) {
            sq.y = sq.size;
            sq.dy = Math.abs(sq.dy);
        } else if (sq.y + sq.size > canvas.height) {
            sq.y = canvas.height - sq.size;
            sq.dy = -Math.abs(sq.dy);
        }

        obstacles.forEach((rect) => handleObstacleCollision(sq, rect));
    });

    handleEntityCollisions();

    triangles.forEach((triangle) => drawTriangle(triangle));
    squares.forEach((sq) => drawSquare(sq));

    requestAnimationFrame(animate);
}

window.addEventListener("resize", () => resizeCanvas());
resizeCanvas();
createTriangles();
createSquares();
requestAnimationFrame(animate);
})();
</script>

<script async id="netlify-rum-container" src="/.netlify/scripts/rum" data-netlify-rum-site-id="8fb4cf1a-160e-4bb5-a696-f9abdfd9c88e" data-netlify-deploy-branch="" data-netlify-deploy-context="production" data-netlify-cwv-token="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzaXRlX2lkIjoiOGZiNGNmMWEtMTYwZS00YmI1LWE2OTYtZjlhYmRmZDljODhlIiwiYWNjb3VudF9pZCI6IjZhNjUyNDlhZTc3OTgwYjNmZjNmMTA1MCIsImRlcGxveV9pZCI6IjZhNjc5ZWYyOGI1MjgxNWJiMTZiNTFlNiIsImlzc3VlciI6Im5mc2VydmVyIn0.pCbdkgj5ZWDmhZ2IH9uHpuV0uhjGODkoDSnTk4SJLng"></script>
</body>
</html>
<!--https://7some.netlify.app-->
<!--https://7some.netlify.app-->