education learning

adult content

English

Within the application-focused generic top-level domain (.app), 'continuous-beige-3b2pdpjcss-x6ijn1dvea.edgeone.app' is registered and includes subdomain 'continuous-beige-3b2pdpjcss-x6ijn1dvea'. The registrable portion 'edgeone' spans 7 characters with 4 vowels and three consonants. Segmentation suggests two words: edge, one. Expect 3.5 characters per word on average. No strong language cues emerged from the frequency lists.

html/e8/b4/e8b468b2-db24-43b6-8e17-6f8d50e169a8_fallback.html.gz

Grammar Arena – Sentence Hero

d8b1731a310549c1e0c7db81d9b5028e10c87e9b8ae633c2c9e9b1d9c3f30081

viewport

HSTS header missing - vulnerable to protocol downgrade attacks

CSP header missing - vulnerable to XSS attacks

child-src 'none';object-src 'none';require-trusted-types-for 'script';script-src chrome://resources 'self';trusted-types;worker-src blob: 'self';frame-ancestors 'none';

child-src https:  chrome-untrusted://new-tab-page/ chrome-untrusted://ntp-microsoft-auth/;connect-src chrome://resources chrome://theme 'self';default-src 'self';font-src chrome://resources 'self';img-src chrome://resources chrome://theme chrome://image chrome://favicon2 chrome://app-icon chrome://extension-icon chrome://fileicon blob: data: 'self';object-src 'none';require-trusted-types-for 'script';script-src chrome://resources chrome://webui-test 'self';style-src chrome://resources chrome://theme 'self' 'unsafe-inline';trusted-types parse-html-subset sanitize-inner-html static-types webui-test-script webui-test-html polymer-html-literal polymer-template-event-attribute-policy lit-html-desktop;frame-ancestors 'none';

child-src 'none';object-src 'none';require-trusted-types-for 'script';script-src chrome://resources 'self';trusted-types;frame-ancestors 'none';

base-uri 'none';child-src https:;form-action https://ogs.google.com https://*.corp.google.com;object-src 'none';script-src 'self' 'unsafe-inline' https:;frame-ancestors chrome://new-tab-page/


    // =========================
    // GAME DATA (GRAMMAR)
    // =========================
    const QUESTIONS = [
      {
        text: "Which one is a COMPLETE sentence?",
        type: "Complete vs Incomplete",
        options: [
          "Ran very fast.",
          "The firefighter saved the cat.",
          "The tall, blue hat.",
          "After the rain stopped."
        ],
        correctIndex: 1
      },
      {
        text: "Which one is INCOMPLETE?",
        type: "Complete vs Incomplete",
        options: [
          "Nurses have important jobs.",
          "After school on Friday.",
          "My brother plays football.",
          "The doctor wore a white coat."
        ],
        correctIndex: 1
      },
      {
        text: "A complete sentence must have:",
        type: "Grammar Rule",
        options: [
          "Only a naming word",
          "Only an action word",
          "A who/what and what happens",
          "More than 10 words"
        ],
        correctIndex: 2
      },
      {
        text: "\"Makes you feel better.\" is:",
        type: "Complete vs Incomplete",
        options: [
          "A complete sentence",
          "An incomplete sentence"
        ],
        correctIndex: 1
      },
      {
        text: "\"The mail in the box.\" is:",
        type: "Complete vs Incomplete",
        options: [
          "A complete sentence",
          "An incomplete sentence"
        ],
        correctIndex: 1
      },
      {
        text: "Grammar is a set of ______ that help us speak and write correctly.",
        type: "Basics",
        options: [
          "Stories",
          "Rules",
          "Games",
          "Pictures"
        ],
        correctIndex: 1
      },
      {
        text: "Choose the COMPLETE sentence.",
        type: "Complete vs Incomplete",
        options: [
          "Visited Costa Rica during vacation.",
          "My family visited Costa Rica during vacation.",
          "After we finish our work.",
          "The noise in the library."
        ],
        correctIndex: 1
      },
      {
        text: "Grammar helps people to:",
        type: "Basics",
        options: [
          "Understand each other",
          "Play video games",
          "Draw pictures",
          "Sleep in class"
        ],
        correctIndex: 0
      }
    ];

    // =========================
    // BASIC SETUP
    // =========================
    const canvas = document.getElementById("gameCanvas");
    const ctx = canvas.getContext("2d");

    const hudQuestion = document.getElementById("hud-question");
    const hudScore = document.getElementById("hud-score");
    const hudTime = document.getElementById("hud-time");
    const hudHearts = document.getElementById("hud-hearts");
    const hudQNum = document.getElementById("hud-questionNumber");
    const hudQTotal = document.getElementById("hud-questionTotal");
    const hudMode = document.getElementById("hud-mode");

    hudQTotal.textContent = QUESTIONS.length.toString();

    const WIDTH = canvas.width;
    const HEIGHT = canvas.height;

    // =========================
    // GAME STATE
    // =========================
    let lastTime = 0;
    let keys = {};
    let score = 0;
    let lives = 3;
    let currentQuestionIndex = 0;
    let timePerQuestion = 15; // seconds
    let timeLeft = timePerQuestion;
    let gameOver = false;
    let gameWon = false;

    const player = {
      x: WIDTH / 2,
      y: HEIGHT / 2,
      radius: 18,
      speed: 260,
      color: "#22c55e",
      vx: 0,
      vy: 0
    };

    const monster = {
      x: WIDTH * 0.75,
      y: HEIGHT * 0.3,
      radius: 22,
      color: "#ef4444",
      vx: -140,
      vy: 120
    };

    let orbs = []; // answer orbs

    // =========================
    // INPUT
    // =========================
    window.addEventListener("keydown", (e) => {
      keys[e.key.toLowerCase()] = true;

      if (gameOver && e.key === " ") {
        restartGame();
      }
    });

    window.addEventListener("keyup", (e) => {
      keys[e.key.toLowerCase()] = false;
    });

    canvas.addEventListener("click", () => {
      if (gameOver) restartGame();
    });

    // =========================
    // UTIL
    // =========================
    function randRange(min, max) {
      return Math.random() * (max - min) + min;
    }

    function distance(x1, y1, x2, y2) {
      const dx = x2 - x1;
      const dy = y2 - y1;
      return Math.sqrt(dx * dx + dy * dy);
    }

    function shuffle(arr) {
      const a = arr.slice();
      for (let i = a.length - 1; i > 0; i--) {
        const j = Math.floor(Math.random() * (i + 1));
        [a[i], a[j]] = [a[j], a[i]];
      }
      return a;
    }

    // =========================
    // QUESTION & ORBS
    // =========================
    function loadQuestion() {
      const q = QUESTIONS[currentQuestionIndex];
      hudQuestion.textContent = q.text;
      hudMode.textContent = q.type;
      hudQNum.textContent = (currentQuestionIndex + 1).toString();
      timeLeft = timePerQuestion;

      // Place answer orbs randomly
      orbs = [];
      const shuffledOptions = shuffle(q.options.map((opt, i) => ({ text: opt, index: i })));

      const areaPadding = 70;
      const orbRadius = 28;

      shuffledOptions.forEach((optObj, idx) => {
        let placed = false;
        let attempts = 0;
        while (!placed && attempts < 50) {
          attempts++;
          const x = randRange(areaPadding, WIDTH - areaPadding);
          const y = randRange(areaPadding + 40, HEIGHT - areaPadding);
          let tooClose = false;
          if (distance(x, y, player.x, player.y) < 120) tooClose = true;
          if (distance(x, y, monster.x, monster.y) < 120) tooClose = true;
          for (const o of orbs) {
            if (distance(x, y, o.x, o.y) < orbRadius * 2 + 10) {
              tooClose = true;
              break;
            }
          }
          if (!tooClose) {
            orbs.push({
              x,
              y,
              radius: orbRadius,
              text: optObj.text,
              isCorrect: optObj.index === q.correctIndex,
              pulseAngle: Math.random() * Math.PI * 2
            });
            placed = true;
          }
        }
      });
    }

    // =========================
    // GAME LOGIC
    // =========================
    function loseLife(reason) {
      lives--;
      if (lives < 0) lives = 0;
      updateHearts();
      flashMessage(reason);

      if (lives <= 0) {
        gameOver = true;
        gameWon = false;
      } else {
        // move player back to center and reload same or next question
        player.x = WIDTH / 2;
        player.y = HEIGHT / 2;
        timeLeft = timePerQuestion;
      }
    }

    function gainScore(amount) {
      score += amount;
      hudScore.textContent = score.toString();
    }

    function updateHearts() {
      const full = "❤️".repeat(lives);
      const empty = "🖤".repeat(3 - lives);
      hudHearts.textContent = full + empty;
    }

    let flashText = "";
    let flashTimer = 0;

    function flashMessage(text, duration = 1.2) {
      flashText = text;
      flashTimer = duration;
    }

    function update(dt) {
      if (gameOver) return;

      // Time
      timeLeft -= dt;
      if (timeLeft < 0) timeLeft = 0;
      hudTime.textContent = timeLeft.toFixed(1);

      if (timeLeft <= 0) {
        loseLife("⏰ Time's up!");
        if (!gameOver) {
          // move to next question
          nextQuestion();
        }
      }

      // Player movement
      let ax = 0;
      let ay = 0;
      if (keys["arrowleft"] || keys["a"]) ax -= 1;
      if (keys["arrowright"] || keys["d"]) ax += 1;
      if (keys["arrowup"] || keys["w"]) ay -= 1;
      if (keys["arrowdown"] || keys["s"]) ay += 1;

      const len = Math.hypot(ax, ay);
      if (len > 0) {
        ax /= len;
        ay /= len;
      }

      player.x += ax * player.speed * dt;
      player.y += ay * player.speed * dt;

      // Clamp player
      player.x = Math.max(player.radius + 10, Math.min(WIDTH - player.radius - 10, player.x));
      player.y = Math.max(player.radius + 10, Math.min(HEIGHT - player.radius - 10, player.y));

      // Monster movement (bouncing)
      monster.x += monster.vx * dt;
      monster.y += monster.vy * dt;

      if (monster.x < monster.radius || monster.x > WIDTH - monster.radius) {
        monster.vx *= -1;
        monster.x = Math.max(monster.radius, Math.min(WIDTH - monster.radius, monster.x));
      }
      if (monster.y < monster.radius + 40 || monster.y > HEIGHT - monster.radius) {
        monster.vy *= -1;
        monster.y = Math.max(monster.radius + 40, Math.min(HEIGHT - monster.radius, monster.y));
      }

      // Monster slight tracking
      const dirToPlayerX = player.x - monster.x;
      const dirToPlayerY = player.y - monster.y;
      const dist = Math.hypot(dirToPlayerX, dirToPlayerY);
      if (dist > 1) {
        monster.vx += (dirToPlayerX / dist) * 10 * dt;
        monster.vy += (dirToPlayerY / dist) * 10 * dt;
        const maxSpeed = 200;
        const mSpeed = Math.hypot(monster.vx, monster.vy);
        if (mSpeed > maxSpeed) {
          monster.vx = (monster.vx / mSpeed) * maxSpeed;
          monster.vy = (monster.vy / mSpeed) * maxSpeed;
        }
      }

      // Collision: player & monster
      if (distance(player.x, player.y, monster.x, monster.y) < player.radius + monster.radius - 4) {
        loseLife("👾 The Grammar Monster got you!");
      }

      // Orbs animations & collisions
      for (const orb of orbs) {
        orb.pulseAngle += dt * 4;
      }

      // Check orb collisions
      for (let i = 0; i < orbs.length; i++) {
        const orb = orbs[i];
        if (distance(player.x, player.y, orb.x, orb.y) < player.radius + orb.radius - 4) {
          if (orb.isCorrect) {
            gainScore(15);
            flashMessage("✅ Nice! Correct grammar!");
            nextQuestion();
          } else {
            loseLife("❌ Wrong answer!");
          }
          break;
        }
      }

      // Flash timer
      if (flashTimer > 0) {
        flashTimer -= dt;
      }
    }

    function nextQuestion() {
      currentQuestionIndex++;
      if (currentQuestionIndex >= QUESTIONS.length) {
        gameOver = true;
        gameWon = true;
      } else {
        loadQuestion();
      }
    }

    function restartGame() {
      score = 0;
      lives = 3;
      updateHearts();
      currentQuestionIndex = 0;
      timeLeft = timePerQuestion;
      gameOver = false;
      gameWon = false;
      player.x = WIDTH / 2;
      player.y = HEIGHT / 2;
      monster.x = WIDTH * 0.75;
      monster.y = HEIGHT * 0.3;
      monster.vx = -140;
      monster.vy = 120;
      hudScore.textContent = "0";
      flashText = "";
      flashTimer = 0;
      loadQuestion();
      lastTime = performance.now();
      requestAnimationFrame(loop);
    }

    // =========================
    // DRAWING
    // =========================
    function drawBackground() {
      // grid / arena lines
      ctx.save();
      ctx.globalAlpha = 0.18;
      ctx.strokeStyle = "#1e40af";
      const gridSize = 40;
      for (let x = 0; x <= WIDTH; x += gridSize) {
        ctx.beginPath();
        ctx.moveTo(x, 0);
        ctx.lineTo(x, HEIGHT);
        ctx.stroke();
      }
      for (let y = 40; y <= HEIGHT; y += gridSize) {
        ctx.beginPath();
        ctx.moveTo(0, y);
        ctx.lineTo(WIDTH, y);
        ctx.stroke();
      }
      ctx.restore();

      // safe zone line
      ctx.save();
      ctx.globalAlpha = 0.2;
      ctx.strokeStyle = "#22c55e";
      ctx.beginPath();
      ctx.moveTo(0, 40);
      ctx.lineTo(WIDTH, 40);
      ctx.stroke();
      ctx.restore();
    }

    function drawPlayer() {
      ctx.save();
      const glowRadius = player.radius + 8;
      const gradient = ctx.createRadialGradient(
        player.x, player.y, player.radius * 0.1,
        player.x, player.y, glowRadius
      );
      gradient.addColorStop(0, "#bbf7d0");
      gradient.addColorStop(1, "rgba(34, 197, 94, 0)");

      ctx.fillStyle = gradient;
      ctx.beginPath();
      ctx.arc(player.x, player.y, glowRadius, 0, Math.PI * 2);
      ctx.fill();

      ctx.fillStyle = player.color;
      ctx.beginPath();
      ctx.arc(player.x, player.y, player.radius, 0, Math.PI * 2);
      ctx.fill();

      // face
      ctx.fillStyle = "#022c22";
      ctx.beginPath();
      ctx.arc(player.x - 6, player.y - 4, 2, 0, Math.PI * 2);
      ctx.arc(player.x + 6, player.y - 4, 2, 0, Math.PI * 2);
      ctx.fill();
      ctx.beginPath();
      ctx.arc(player.x, player.y + 5, 6, 0, Math.PI);
      ctx.strokeStyle = "#022c22";
      ctx.lineWidth = 1.5;
      ctx.stroke();

      ctx.restore();
    }

    function drawMonster() {
      ctx.save();
      const gradient = ctx.createRadialGradient(
        monster.x, monster.y, 4,
        monster.x, monster.y, monster.radius + 10
      );
      gradient.addColorStop(0, "#fecaca");
      gradient.addColorStop(1, "rgba(248, 113, 113, 0)");

      ctx.fillStyle = gradient;
      ctx.beginPath();
      ctx.arc(monster.x, monster.y, monster.radius + 10, 0, Math.PI * 2);
      ctx.fill();

      ctx.fillStyle = monster.color;
      ctx.beginPath();
      ctx.arc(monster.x, monster.y, monster.radius, 0, Math.PI * 2);
      ctx.fill();

      // eyes
      ctx.fillStyle = "#111827";
      ctx.beginPath();
      ctx.arc(monster.x - 6, monster.y - 5, 3, 0, Math.PI * 2);
      ctx.arc(monster.x + 6, monster.y - 5, 3, 0, Math.PI * 2);
      ctx.fill();

      // mouth
      ctx.beginPath();
      ctx.arc(monster.x, monster.y + 4, 8, 0, Math.PI);
      ctx.fillStyle = "#111827";
      ctx.fill();

      // teeth
      ctx.fillStyle = "#fefce8";
      ctx.beginPath();
      ctx.moveTo(monster.x - 5, monster.y + 4);
      ctx.lineTo(monster.x - 2, monster.y + 10);
      ctx.lineTo(monster.x + 1, monster.y + 4);
      ctx.closePath();
      ctx.fill();

      ctx.beginPath();
      ctx.moveTo(monster.x + 5, monster.y + 4);
      ctx.lineTo(monster.x + 2, monster.y + 10);
      ctx.lineTo(monster.x - 1, monster.y + 4);
      ctx.closePath();
      ctx.fill();

      ctx.restore();
    }

    function drawOrbs() {
      ctx.save();
      ctx.textAlign = "center";
      ctx.textBaseline = "middle";
      ctx.font = "13px system-ui, sans-serif";

      for (const orb of orbs) {
        const pulse = Math.sin(orb.pulseAngle) * 3;
        const r = orb.radius + pulse;

        const gradient = ctx.createRadialGradient(
          orb.x, orb.y, 5,
          orb.x, orb.y, r
        );
        gradient.addColorStop(0, "#e0f2fe");
        gradient.addColorStop(1, "#1d4ed8");

        ctx.fillStyle = gradient;
        ctx.beginPath();
        ctx.arc(orb.x, orb.y, r, 0, Math.PI * 2);
        ctx.fill();

        ctx.fillStyle = "#0f172a";
        ctx.beginPath();
        ctx.arc(orb.x, orb.y, r - 4, 0, Math.PI * 2);
        ctx.fill();

        ctx.fillStyle = "#e5e7eb";
        ctx.fillText(orb.text, orb.x, orb.y);
      }

      ctx.restore();
    }

    function drawOverlay() {
      if (!gameOver && flashTimer <= 0) return;

      ctx.save();

      if (gameOver) {
        ctx.fillStyle = "rgba(15,23,42,0.82)";
        ctx.fillRect(0, 0, WIDTH, HEIGHT);

        ctx.fillStyle = "#e5e7eb";
        ctx.textAlign = "center";
        ctx.font = "30px system-ui";
        ctx.fillText(gameWon ? "Grammar Hero!" : "Game Over", WIDTH / 2, HEIGHT / 2 - 20);

        ctx.font = "16px system-ui";
        const percent = Math.round((score / (QUESTIONS.length * 15)) * 100);
        ctx.fillText(`Score: ${score}   (${percent}%)`, WIDTH / 2, HEIGHT / 2 + 8);
        ctx.font = "14px system-ui";
        ctx.fillText("Press SPACE or click to play again", WIDTH / 2, HEIGHT / 2 + 40);
      } else if (flashTimer > 0 && flashText) {
        ctx.globalAlpha = Math.min(1, flashTimer * 2);
        ctx.fillStyle = "rgba(15,23,42,0.7)";
        ctx.fillRect(0, HEIGHT - 60, WIDTH, 60);
        ctx.fillStyle = "#e5e7eb";
        ctx.textAlign = "center";
        ctx.font = "16px system-ui";
        ctx.fillText(flashText, WIDTH / 2, HEIGHT - 30);
      }

      ctx.restore();
    }

    function draw() {
      ctx.clearRect(0, 0, WIDTH, HEIGHT);
      drawBackground();
      drawOrbs();
      drawPlayer();
      drawMonster();
      drawOverlay();
    }

    // =========================
    // MAIN LOOP
    // =========================
    function loop(timestamp) {
      const dt = (timestamp - lastTime) / 1000;
      lastTime = timestamp;
      update(dt);
      draw();
      if (!gameOver) requestAnimationFrame(loop);
      else draw(); // draw one more time with overlay
    }

    // =========================
    // START
    // =========================
    updateHearts();
    loadQuestion();
    lastTime = performance.now();
    requestAnimationFrame(loop);
  

View security analysis for https://continuous-beige-3b2pdpjcss-x6ijn1dvea.edgeone.app/

Requests	IP Address	Location	AS Autonomous System
2	43.152.26.58	Singapore	AS139341ACE
2	1	-	-

Security Scan Report: continuous-beige-3b2pdpjcss-x6ijn1dvea.edgeone.app

Summary

AI Security Verdict

Low Risk

Safety Factors

Details

Screenshot

Page Load Overview

Language Analysis

Primary Language

Detection Details

Website Classification

Primary Category

All Detected Categories

Detected Features

Domain & IP Information

Content Similarity HashesFor malware variant detection

TLSH (Trend Micro Locality Sensitive Hash)

ssdeep (Context Triggered Piecewise Hashing)

sdhash (Similarity Digest Hashing)

Image Hashes

Perceptual Hashes

Other Hashes

Scan History