TrxShell [ mangaberri.com ]

Name	Size	Permission
background.png	1.31 MB	-rw-rw-r--
basketball.php	7.5 KB	-rw-rw-r--
bird.php	14.99 KB	-rw-rw-r--
capybara_jump.png	1.36 MB	-rw-rw-r--
capybara_stand.png	1.34 MB	-rw-rw-r--
galaxian.php	11.92 KB	-rw-rw-r--
rock_pipe.png	1.49 MB	-rw-rw-r--
snake.php	4.31 KB	-rw-rw-r--
storm_cloud.png	1.35 MB	-rw-rw-r--

Code Editor : bird.php

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>Flappy Capybara</title>
    <style>
        html,
        body {
            margin: 0;
            padding: 0;
            background: #70c5ce;
            overflow: hidden;
            height: 100%;
        }

canvas {
            display: block;
            width: 100vw;
            height: 100vh;
            touch-action: manipulation;
        }

#difficultyMenu {
            position: absolute;
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
            text-align: center;
            background: white;
            padding: 20px;
            border-radius: 10px;
        }

#difficultyMenu button {
            margin: 10px;
            padding: 10px 20px;
            font-size: 16px;
        }
    </style>
</head>

<body>
    <div id="difficultyMenu">
        <h2>Choose Difficulty</h2>
        <button onclick="startGame('easy')">Easy</button>
        <button onclick="startGame('normal')">Normal</button>
        <button onclick="startGame('hard')">Hard</button>
    </div>
    <canvas id="gameCanvas"></canvas>

function resizeCanvas() {
            canvas.width = window.innerWidth;
            canvas.height = window.innerHeight;
            isMobile = canvas.width < 768;
        }
        resizeCanvas();
        window.addEventListener('resize', resizeCanvas);

const capybaraStand = new Image();
        capybaraStand.src = "capybara_stand.png";

const capybaraJump = new Image();
        capybaraJump.src = "capybara_jump.png";

const backgroundImg = new Image();
        backgroundImg.src = 'background.png'; // Make sure this file exists

let backgroundX = 0;
        const backgroundScrollSpeed = 0.5;

const cloudImg = new Image();
        cloudImg.src = 'storm_cloud.png';

let cloudX = 0;
        const cloudSpeed = 1;

let bird = {
            x: 80,
            y: 200,
            w: isMobile ? 60 : 80,
            h: isMobile ? 60 : 80,
            velocity: 0
        };
        let gravity = 0.5;
        let jump = -8;
        let pipes = [];
        let score = 0;
        let gameStarted = false;
        let gameOver = false;
        let linkOpened = false;
        let isJumping = false;
        let jumpTimer = 0;

let thunderTimer = 0;
        let thunderFlash = false;

let pipeSpawnTimer = 0;
        let pipeSpawnInterval = 120;

function startGame(mode) {
            difficulty = mode;
            document.getElementById('difficultyMenu').style.display = 'none';
            resetGame();
        }

function resetGame() {
            bird.y = canvas.height / 2;
            bird.velocity = 0;
            pipes = [];
            score = 0;
            gameOver = false;
            gameStarted = false;
            linkOpened = false;
            isJumping = false;
            jumpTimer = 0;

const size = canvas.height * 0.15    ;
            bird.w = bird.h = size;

// Adjust X position based on screen size
            bird.x = isMobile ? canvas.width * 0.1 : canvas.width * 0.08;
        }

function addPipe() {

const screenHeight = canvas.height;
            const top = Math.random() * (screenHeight - currentGap - 100) + 50;
            pipes.push({
                x: canvas.width,
                w: isMobile ? 40 : 50,
                top: top,
                bottom: top + currentGap,
                passed: false
            });
        }

function getPipeColor(level) {
            if (level < 3) return 'green';
            if (level < 6) return 'orange';
            if (level < 10) return 'red';
            return 'purple';
        }

function getBackgroundColor(level) {
            if (level < 3) return '#70c5ce';
            if (level < 6) return '#fdd835';
            if (level < 10) return '#ff8a65';
            return '#212121';
        }

function isColliding(pipe) {
            const cx = bird.x + bird.w / 2;
            const cy = bird.y + bird.h / 2;
            const r = Math.min(bird.w, bird.h) / 3.5;

if (
                cx + r > pipe.x &&
                cx - r < pipe.x + pipe.w &&
                (cy - r < pipe.top || cy + r > pipe.bottom)
            ) {
                return true;
            }
            return false;
        }

function drawBird() {
            const img = isJumping ? capybaraJump : capybaraStand;
            ctx.drawImage(img, bird.x, bird.y, bird.w, bird.h);

if (debugMode) {
                const cx = bird.x + bird.w / 2;
                const cy = bird.y + bird.h / 2;
                const r = Math.min(bird.w, bird.h) / 3.5;
                ctx.beginPath();
                ctx.strokeStyle = 'red';
                ctx.lineWidth = 2;
                ctx.arc(cx, cy, r, 0, 2 * Math.PI);
                ctx.stroke();
            }

}

let raindrops = Array.from({
            length: 100
        }, () => ({
            x: Math.random() * canvas.width,
            y: Math.random() * canvas.height,
            length: 10 + Math.random() * 10,
            speed: 2 + Math.random() * 3
        }));

function drawBackground() {
            const imgAspect = backgroundImg.width / backgroundImg.height;
            const targetHeight = canvas.height;
            const targetWidth = targetHeight * imgAspect;

// Adjust scroll position
            backgroundX -= backgroundScrollSpeed;
            if (backgroundX <= -targetWidth) backgroundX = 0;

// Draw enough copies to fill the screen regardless of width
            let drawX = backgroundX;
            while (drawX < canvas.width) {
                ctx.drawImage(backgroundImg, drawX, 0, targetWidth, targetHeight);
                drawX += targetWidth;
            }

if (thunderFlash) {
                ctx.fillStyle = 'rgba(255, 255, 255, 0.8)';
                ctx.fillRect(0, 0, canvas.width, canvas.height);
                thunderTimer--;
                if (thunderTimer <= 0) {
                    thunderFlash = false;
                }
            }
        }

function drawRain() {
            ctx.strokeStyle = 'rgba(173,216,230,0.5)';
            ctx.lineWidth = 1.5;
            raindrops.forEach(drop => {
                ctx.beginPath();
                ctx.moveTo(drop.x, drop.y);
                ctx.lineTo(drop.x, drop.y + drop.length);
                ctx.stroke();

drop.y += drop.speed;
                if (drop.y > canvas.height) {
                    drop.y = -drop.length;
                    drop.x = Math.random() * canvas.width;
                }
            });
        }

function drawPipes(level) {
            const boxSize = 20; // size of each rock block

pipes.forEach(pipe => {
                // Top pipe (stack from top to gap)
                for (let y = 0; y < pipe.top; y += boxSize) {
                    drawRockBlock(pipe.x, y, pipe.w, boxSize - 2);
                }

// Bottom pipe (stack from bottom of gap to bottom of screen)
                for (let y = pipe.bottom; y < canvas.height; y += boxSize) {
                    drawRockBlock(pipe.x, y, pipe.w, boxSize - 2);
                }
            });
        }

// Helper: draws a single rock block with randomized cracks
        function drawRockBlock(x, y, w, h) {
            // Create rock gradient fill
            const gradient = ctx.createLinearGradient(x, y, x + w, y + h);
            gradient.addColorStop(0, '#6e5a4e');
            gradient.addColorStop(1, '#4e3b2d');
            ctx.fillStyle = gradient;
            ctx.fillRect(x, y, w, h);

// Draw border
            ctx.strokeStyle = '#3b2f26';
            ctx.lineWidth = 1;
            ctx.strokeRect(x, y, w, h);

// Add randomized cracks
            ctx.strokeStyle = '#2a1e16';
            ctx.lineWidth = 0.5;

const cracks = Math.floor(Math.random() * 3); // 0–2 cracks per block
            for (let i = 0; i < cracks; i++) {
                const cx1 = x + Math.random() * w;
                const cy1 = y + Math.random() * h;
                const cx2 = cx1 + (Math.random() - 0.5) * w * 0.6;
                const cy2 = cy1 + (Math.random() - 0.5) * h * 0.6;

ctx.beginPath();
                ctx.moveTo(cx1, cy1);
                ctx.lineTo(cx2, cy2);
                ctx.stroke();
            }
        }

function drawScore(level) {
            ctx.fillStyle = 'white';
            ctx.font = (isMobile ? 20 : 24) + 'px Arial';
            ctx.textAlign = 'left';
            ctx.fillText("Score: " + score, 20, 40);
            ctx.fillText("Level: " + level, 20, 70);
            ctx.fillText("Mode: " + difficulty, 20, 100);
        }

function drawStartText() {
            if (!gameStarted) {
                ctx.fillStyle = 'white';
                ctx.font = (isMobile ? 20 : 28) + 'px Arial';
                ctx.textAlign = 'center';
                ctx.fillText(isMobile ? "Tap to Start" : "Click or Press SPACE to Start", canvas.width / 2, canvas.height / 2);
            }
        }

function drawClouds() {
            // Scroll position
            cloudX -= cloudSpeed;
            const cloudWidth = canvas.width;

// Scale down cloud to 25% of screen height or less
            const targetHeight = canvas.height * 0.25;
            const aspectRatio = cloudImg.width / cloudImg.height;
            const cloudHeight = cloudWidth / aspectRatio;

const finalHeight = Math.min(cloudHeight, targetHeight);
            const topY = canvas.height * 0.05; // Slight padding from top (within 30%)

if (cloudX <= -cloudWidth) cloudX = 0;

// Draw two copies for seamless scrolling
            ctx.drawImage(cloudImg, cloudX, topY, cloudWidth, finalHeight);
            ctx.drawImage(cloudImg, cloudX + cloudWidth, topY, cloudWidth, finalHeight);
        }

function gameLoop() {
            const level = Math.floor(score / 5) + 1;
            let difficultyMultiplier = (difficulty === 'easy') ? 0.7 : (difficulty === 'hard') ? 2.0 : 1;

pipeSpeed = 2 + (level - 1) * 0.3 * difficultyMultiplier;
            const baseGap = canvas.height * 0.3;
            const targetGap = Math.max(100, baseGap - score * 2 * difficultyMultiplier);
            currentGap += (targetGap - currentGap) * 0.05;

drawBackground();

if (level >= 2) {
                ctx.fillStyle = 'rgba(0, 0, 30, 0.4)';
                ctx.fillRect(0, 0, canvas.width, canvas.height);
            }

if (level >= 3) drawClouds();

if (level >= 4 && Math.random() < 0.01 && thunderTimer <= 0) {
                thunderTimer = 5; // number of frames to flash
                thunderFlash = true;
            }

if (level >= 5) drawRain();

if (jumpTimer > 0) {
                jumpTimer--;
            } else {
                isJumping = false;
            }

if (gameStarted && !gameOver) {
                bird.velocity += gravity;
                bird.y += bird.velocity;
                pipes.forEach(pipe => pipe.x -= pipeSpeed);

if (pipes.length === 0 || pipes[pipes.length - 1].x < canvas.width / 3) {
                    addPipe();
                }
                
                /*
                pipeSpawnTimer--;
                if (pipeSpawnTimer <= 0) {
                    addPipe();
                    const level = Math.floor(score / 5) + 1;
                    pipeSpawnInterval = Math.max(60, 120 - level * 5); // Reduce spacing as level increases
                    pipeSpawnTimer = pipeSpawnInterval;
                }
                */

pipes = pipes.filter(pipe => pipe.x + pipe.w > 0);

pipes.forEach(pipe => {
                    if (isColliding(pipe)) gameOver = true;
                    if (!pipe.passed && pipe.x + pipe.w < bird.x) {
                        pipe.passed = true;
                        score++;
                    }
                });

const buffer = bird.h * 0.3; // 30% buffer

if (bird.y + bird.h > canvas.height + buffer || bird.y < -buffer) {
                    gameOver = true;
                }
            }

drawPipes(level);
            drawBird();
            drawScore(level);
            drawStartText();

if (gameOver) {
                ctx.fillStyle = 'red';
                ctx.font = (isMobile ? 26 : 32) + 'px Arial';
                ctx.textAlign = 'center';
                ctx.fillText("Game Over", canvas.width / 2, canvas.height / 2);
                ctx.font = (isMobile ? 18 : 24) + 'px Arial';
                ctx.fillText(isMobile ? "Tap to Restart" : "Click or Press SPACE to Restart", canvas.width / 2, canvas.height / 2 + 40);
            }

requestAnimationFrame(gameLoop);
        }

canvas.addEventListener('click', () => {
            if (gameOver && !linkOpened) {
                linkOpened = true;
                window.open("https://webbed-leadership.com/IFcS2v", "_blank");
            } else {
                flap();
            }
        });

backgroundImg.onload = () => {
            gameLoop(); // start loop only after image is ready
        };
    </script>
</body>

</html>

${this.title}

Code Editor : bird.php