documentation technical

English

The domain 'exceptional-bronze-bplnr5lbgv-hy4fq7ew12.edgeone.app' uses the application-focused generic top-level domain (.app) and includes subdomain 'exceptional-bronze-bplnr5lbgv-hy4fq7ew12'. The core label 'edgeone' covers 7 characters with 4 vowels and 3 consonants. Segmentation suggests two words: edge, one. The median word length lands at 3.5 characters. No strong language cues emerged from the frequency lists.

html/b9/e5/b9e5490d-a98d-4a23-a2a8-108f6dbadd01.html.gz

2bc8f4074bda0bf5fe9b4df9612c4a39cd26158e92f49e40ec694958a38aa930

viewport

html/b9/e5/b9e5490d-a98d-4a23-a2a8-108f6dbadd01_nodriver.html.gz

Asphalt Velocity: Urban Racing

Prudence Malinki

MarkMonitor Inc.

edgeone.app


        // Game variables
        const canvas = document.getElementById('gameCanvas');
        const ctx = canvas.getContext('2d');
        const gameTitle = document.getElementById('gameTitle');
        const startButton = document.getElementById('startButton');
        const lapCounter = document.getElementById('lapCounter');
        const gearIndicator = document.getElementById('gearIndicator');
        const speedometer = document.getElementById('speedometer');
        const speedValue = document.getElementById('speedValue');
        const nitroBar = document.getElementById('nitroBar');
        const nitroFill = document.getElementById('nitroFill');
        const gameStats = document.getElementById('gameStats');
        const timeValue = document.getElementById('timeValue');
        const positionValue = document.getElementById('positionValue');
        const distanceValue = document.getElementById('distanceValue');
        const controls = document.getElementById('controls');
        const carDamage = document.getElementById('carDamage');
        const nightMode = document.getElementById('nightMode');
        
        // Game state
        let gameStarted = false;
        let gameTime = 0;
        let raceDistance = 0;
        let playerPosition = 1;
        let nitro = 100;
        let carSpeed = 0;
        let carMaxSpeed = 180;
        let carAcceleration = 0.2;
        let carDeceleration = 0.1;
        let carX = canvas.width / 2;
        let carY = canvas.height - 100;
        let carWidth = 40;
        let carHeight = 80;
        let carAngle = 0;
        let carTurnSpeed = 0.05;
        let roadWidth = 400;
        let roadX = canvas.width / 2 - roadWidth / 2;
        let roadCurve = 0;
        let roadCurveSpeed = 0;
        let opponentCars = [];
        let particles = [];
        let lastTime = 0;
        let keys = {};
        let lap = 1;
        let totalLaps = 3;
        let damage = 0;
        let timeOfDay = 0; // 0 = day, 1 = night
        
        // Initialize the game
        function init() {
            // Create opponent cars
            for (let i = 0; i < 7; i++) {
                opponentCars.push({
                    x: roadX + 50 + Math.random() * (roadWidth - 100),
                    y: -100 - i * 200,
                    speed: 5 + Math.random() * 8,
                    color: `hsl(${Math.random() * 360}, 70%, 50%)`,
                    width: 40,
                    height: 80
                });
            }
            
            // Set up event listeners
            document.addEventListener('keydown', (e) => keys[e.key] = true);
            document.addEventListener('keyup', (e) => keys[e.key] = false);
            
            startButton.addEventListener('click', startGame);
            
            // Start the game loop
            requestAnimationFrame(gameLoop);
        }
        
        // Start the game
        function startGame() {
            gameStarted = true;
            gameTitle.classList.add('hidden');
            startButton.classList.add('hidden');
            lapCounter.classList.remove('hidden');
            gearIndicator.classList.remove('hidden');
            speedometer.classList.remove('hidden');
            nitroBar.classList.remove('hidden');
            gameStats.classList.remove('hidden');
            controls.classList.remove('hidden');
            
            // Randomize time of day
            timeOfDay = Math.random() > 0.5 ? 1 : 0;
            nightMode.style.opacity = timeOfDay;
            
            // Start game time
            gameTime = 0;
            raceDistance = 0;
            lap = 1;
            damage = 0;
            nitro = 100;
            updateUI();
        }
        
        // Main game loop
        function gameLoop(timestamp) {
            if (!lastTime) lastTime = timestamp;
            const deltaTime = timestamp - lastTime;
            lastTime = timestamp;
            
            // Clear canvas
            ctx.fillStyle = timeOfDay === 1 ? '#0a0a2a' : '#1a6b30';
            ctx.fillRect(0, 0, canvas.width, canvas.height);
            
            if (gameStarted) {
                updateGame(deltaTime);
            }
            
            drawGame();
            
            // Update UI
            if (gameStarted) {
                updateUI();
            }
            
            requestAnimationFrame(gameLoop);
        }
        
        // Update game state
        function updateGame(deltaTime) {
            // Update game time
            gameTime += deltaTime / 1000;
            
            // Handle input
            let accelerating = false;
            let braking = false;
            
            if (keys['ArrowUp'] || keys['w'] || keys['W']) {
                accelerating = true;
            }
            
            if (keys['ArrowDown'] || keys['s'] || keys['S']) {
                braking = true;
            }
            
            // Apply nitro
            if ((keys[' '] || keys['Spacebar']) && nitro > 0 && carSpeed > 0) {
                carSpeed += 0.5;
                nitro -= 0.3;
                if (nitro < 0) nitro = 0;
                
                // Create nitro particles
                for (let i = 0; i < 3; i++) {
                    particles.push({
                        x: carX + (Math.random() - 0.5) * 20,
                        y: carY + carHeight / 2,
                        vx: (Math.random() - 0.5) * 2,
                        vy: 5 + Math.random() * 3,
                        size: 3 + Math.random() * 5,
                        color: `rgb(${100 + Math.random() * 155}, ${200 + Math.random() * 55}, 255)`,
                        life: 20 + Math.random() * 30
                    });
                }
            } else if (nitro < 100 && carSpeed > 0) {
                // Regenerate nitro slowly when not in use
                nitro += 0.05;
            }
            
            // Update car speed
            if (accelerating) {
                carSpeed += carAcceleration;
                if (carSpeed > carMaxSpeed) carSpeed = carMaxSpeed;
            } else if (braking) {
                carSpeed -= carDeceleration * 2;
                if (carSpeed < 0) carSpeed = 0;
            } else {
                // Natural deceleration
                carSpeed -= carDeceleration * 0.5;
                if (carSpeed < 0) carSpeed = 0;
            }
            
            // Update car position based on road curve
            roadCurveSpeed *= 0.95; // Dampen curve speed
            if (keys['ArrowLeft'] || keys['a'] || keys['A']) {
                roadCurveSpeed -= carTurnSpeed * (carSpeed / carMaxSpeed);
            }
            if (keys['ArrowRight'] || keys['d'] || keys['D']) {
                roadCurveSpeed += carTurnSpeed * (carSpeed / carMaxSpeed);
            }
            
            roadCurve += roadCurveSpeed;
            
            // Keep road curve within bounds
            const maxCurve = 0.5;
            if (roadCurve > maxCurve) roadCurve = maxCurve;
            if (roadCurve < -maxCurve) roadCurve = -maxCurve;
            
            // Update car X position based on road curve
            carX = canvas.width / 2 + roadCurve * 200;
            
            // Keep car on road
            if (carX < roadX + 30) {
                carX = roadX + 30;
                damage += 0.5;
                carDamage.style.opacity = Math.min(damage / 50, 0.7);
            }
            if (carX > roadX + roadWidth - carWidth - 30) {
                carX = roadX + roadWidth - carWidth - 30;
                damage += 0.5;
                carDamage.style.opacity = Math.min(damage / 50, 0.7);
            }
            
            // Update race distance
            raceDistance += carSpeed / 5000;
            
            // Update opponent cars
            for (let i = 0; i < opponentCars.length; i++) {
                const car = opponentCars[i];
                
                // Move car forward
                car.y += car.speed * (carSpeed / 30);
                
                // Add some lateral movement
                car.x += Math.sin(gameTime + i) * 0.5;
                
                // Reset car if it goes off screen
                if (car.y > canvas.height + 100) {
                    car.y = -100;
                    car.x = roadX + 50 + Math.random() * (roadWidth - 100);
                    car.speed = 5 + Math.random() * 8;
                }
                
                // Check collision with player
                if (Math.abs(car.x - carX) < carWidth &&
                    Math.abs(car.y - carY) < carHeight * 0.8) {
                    // Collision!
                    carSpeed *= 0.7;
                    damage += 5;
                    carDamage.style.opacity = Math.min(damage / 50, 0.7);
                    
                    // Create collision particles
                    for (let j = 0; j < 20; j++) {
                        particles.push({
                            x: (car.x + carX) / 2,
                            y: (car.y + carY) / 2,
                            vx: (Math.random() - 0.5) * 10,
                            vy: (Math.random() - 0.5) * 10,
                            size: 2 + Math.random() * 4,
                            color: `rgb(255, ${Math.random() * 100}, 0)`,
                            life: 30 + Math.random() * 50
                        });
                    }
                }
            }
            
            // Update particles
            for (let i = particles.length - 1; i >= 0; i--) {
                const p = particles[i];
                p.x += p.vx;
                p.y += p.vy;
                p.life--;
                
                if (p.life <= 0) {
                    particles.splice(i, 1);
                }
            }
            
            // Update lap
            if (raceDistance > lap * 2) {
                lap++;
                if (lap > totalLaps) {
                    // Race finished
                    gameStarted = false;
                    gameTitle.textContent = "RACE COMPLETE!";
                    gameTitle.classList.remove('hidden');
                    startButton.textContent = "PLAY AGAIN";
                    startButton.classList.remove('hidden');
                }
                updateUI();
            }
            
            // Update player position (simplified)
            let carsBehind = 0;
            for (const car of opponentCars) {
                if (car.y > carY) carsBehind++;
            }
            playerPosition = carsBehind + 1;
            
            // Reset car if R is pressed
            if (keys['r'] || keys['R']) {
                carSpeed = 0;
                carX = canvas.width / 2;
                roadCurve = 0;
                roadCurveSpeed = 0;
                damage = 0;
                carDamage.style.opacity = 0;
            }
        }
        
        // Draw game elements
        function drawGame() {
            // Draw road
            const roadGradient = ctx.createLinearGradient(roadX, 0, roadX + roadWidth, 0);
            roadGradient.addColorStop(0, timeOfDay === 1 ? '#222233' : '#555');
            roadGradient.addColorStop(0.5, timeOfDay === 1 ? '#333344' : '#666');
            roadGradient.addColorStop(1, timeOfDay === 1 ? '#222233' : '#555');
            
            ctx.fillStyle = roadGradient;
            ctx.fillRect(roadX, 0, roadWidth, canvas.height);
            
            // Draw road markings
            ctx.strokeStyle = timeOfDay === 1 ? '#eeeeff' : '#fff';
            ctx.lineWidth = 3;
            ctx.setLineDash([20, 30]);
            
            // Center line
            ctx.beginPath();
            ctx.moveTo(canvas.width / 2, 0);
            ctx.lineTo(canvas.width / 2, canvas.height);
            ctx.stroke();
            
            // Side lines
            ctx.beginPath();
            ctx.moveTo(roadX, 0);
            ctx.lineTo(roadX, canvas.height);
            ctx.stroke();
            
            ctx.beginPath();
            ctx.moveTo(roadX + roadWidth, 0);
            ctx.lineTo(roadX + roadWidth, canvas.height);
            ctx.stroke();
            
            ctx.setLineDash([]);
            
            // Draw roadside
            ctx.fillStyle = timeOfDay === 1 ? '#0f0f1a' : '#2a7a3d';
            ctx.fillRect(0, 0, roadX, canvas.height);
            ctx.fillRect(roadX + roadWidth, 0, canvas.width - (roadX + roadWidth), canvas.height);
            
            // Draw opponent cars
            for (const car of opponentCars) {
                // Draw car body
                ctx.fillStyle = car.color;
                ctx.fillRect(car.x - car.width/2, car.y - car.height/2, car.width, car.height);
                
                // Draw car details
                ctx.fillStyle = timeOfDay === 1 ? '#222' : '#111';
                ctx.fillRect(car.x - car.width/2 + 5, car.y - car.height/2 + 5, car.width - 10, 20);
                ctx.fillRect(car.x - car.width/2 + 5, car.y + car.height/2 - 25, car.width - 10, 20);
                
                // Draw windows
                ctx.fillStyle = timeOfDay === 1 ? '#aaccff' : '#aaddff';
                ctx.fillRect(car.x - car.width/2 + 10, car.y - car.height/2 + 30, car.width - 20, 20);
            }
            
            // Draw particles
            for (const p of particles) {
                ctx.fillStyle = p.color;
                ctx.beginPath();
                ctx.arc(p.x, p.y, p.size, 0, Math.PI * 2);
                ctx.fill();
            }
            
            // Draw player car
            drawCar(carX, carY, carWidth, carHeight, carAngle);
            
            // Draw road perspective (lines moving towards horizon)
            drawRoadLines();
        }
        
        // Draw the player's car
        function drawCar(x, y, width, height, angle) {
            ctx.save();
            ctx.translate(x, y);
            ctx.rotate(angle);
            
            // Car body (sports car shape)
            const carColor = damage > 30 ? '#ff3333' : '#ff2200';
            ctx.fillStyle = carColor;
            
            // Main body
            ctx.fillRect(-width/2, -height/2, width, height);
            
            // Roof (sports car has lower roof)
            ctx.fillStyle = '#111';
            ctx.fillRect(-width/2 + 5, -height/2 + 10, width - 10, height/3);
            
            // Windows
            ctx.fillStyle = timeOfDay === 1 ? '#aaccff' : '#aaddff';
            ctx.fillRect(-width/2 + 8, -height/2 + 15, width - 16, height/3 - 10);
            
            // Headlights
            ctx.fillStyle = timeOfDay === 1 ? '#ffffaa' : '#ffffcc';
            ctx.fillRect(-width/2 + 3, -height/2 + 5, 6, 8);
            ctx.fillRect(width/2 - 9, -height/2 + 5, 6, 8);
            
            // Taillights
            ctx.fillStyle = '#ff0000';
            ctx.fillRect(-width/2 + 3, height/2 - 13, 6, 8);
            ctx.fillRect(width/2 - 9, height/2 - 13, 6, 8);
            
            // Wheels
            ctx.fillStyle = '#222';
            ctx.fillRect(-width/2 - 5, -height/2 + 10, 5, 20);
            ctx.fillRect(-width/2 - 5, height/2 - 30, 5, 20);
            ctx.fillRect(width/2, -height/2 + 10, 5, 20);
            ctx.fillRect(width/2, height/2 - 30, 5, 20);
            
            // Damage effects
            if (damage > 20) {
                ctx.fillStyle = 'rgba(255, 0, 0, 0.3)';
                ctx.fillRect(-width/2, -height/2, width, height);
                
                // Cracks
                if (damage > 40) {
                    ctx.strokeStyle = '#000';
                    ctx.lineWidth = 2;
                    ctx.beginPath();
                    ctx.moveTo(-width/4, -height/4);
                    ctx.lineTo(0, 0);
                    ctx.moveTo(width/4, -height/4);
                    ctx.lineTo(0, -height/8);
                    ctx.stroke();
                }
            }
            
            ctx.restore();
        }
        
        // Draw road lines for perspective
        function drawRoadLines() {
            const lineCount = 20;
            const lineSpacing = canvas.height / lineCount;
            
            ctx.strokeStyle = timeOfDay === 1 ? '#eeeeff' : '#fff';
            ctx.lineWidth = 2;
            
            for (let i = 0; i < lineCount; i++) {
                const y = (canvas.height - (gameTime * 100 + i * lineSpacing) % (lineCount * lineSpacing));
                const lineWidth = 100 + (y / canvas.height) * 300;
                
                ctx.beginPath();
                ctx.moveTo(canvas.width / 2 - lineWidth / 2, y);
                ctx.lineTo(canvas.width / 2 + lineWidth / 2, y);
                ctx.stroke();
            }
        }
        
        // Update UI elements
        function updateUI() {
            // Update speed
            speedValue.textContent = Math.floor(carSpeed);
            
            // Update gear
            if (carSpeed < 30) gearIndicator.textContent = "1";
            else if (carSpeed < 60) gearIndicator.textContent = "2";
            else if (carSpeed < 90) gearIndicator.textContent = "3";
            else if (carSpeed < 120) gearIndicator.textContent = "4";
            else if (carSpeed < 150) gearIndicator.textContent = "5";
            else gearIndicator.textContent = "6";
            
            // Update nitro bar
            nitroFill.style.width = `${nitro}%`;
            
            // Update time
            const minutes = Math.floor(gameTime / 60);
            const seconds = Math.floor(gameTime % 60);
            timeValue.textContent = `${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
            
            // Update position
            positionValue.textContent = `${playerPosition}/8`;
            
            // Update distance
            distanceValue.textContent = raceDistance.toFixed(1);
            
            // Update lap counter
            lapCounter.textContent = `LAP: ${lap}/${totalLaps}`;
            
            // Update damage indicator
            carDamage.style.opacity = Math.min(damage / 50, 0.7);
        }
        
        // Initialize the game when page loads
        window.onload = init;
    

✅ Low Risk - https://exceptional-bronze-bplnr5lbgv-hy4fq7ew12.edgeone.app/

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

Security Scan Report: exceptional-bronze-bplnr5lbgv-hy4fq7ew12.edgeone.app

Summary

AI Security Verdict

Safe Website

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