entertainment media

Dutch

You're looking at domain 'aggressive-blush-5xmks1yoqv-46abtion77.edgeone.app' on the application-focused generic top-level domain (.app); it also runs on subdomain 'aggressive-blush-5xmks1yoqv-46abtion77'. The core label 'edgeone' covers 7 characters with 4 vowels and 3 consonants. Tokenizing the label suggests two words: edge, one. Expect 3.5 characters per word on average. No strong language cues emerged from the frequency lists.

html/29/30/2930c055-8f6f-4ec2-95fb-f1f6f90acc3b.html.gz

9274bbcec8d96168626c732b5d31c775aa8cfb7eaa0599bec0c175908a2c1ce2

7814d02f64f9e47cfd1fd8adea32b05192cca3d65618e4bb1e5b5c3a15745e52

width=device-width, initial-scale=1.0, user-scalable=no

viewport

html/29/30/2930c055-8f6f-4ec2-95fb-f1f6f90acc3b_nodriver.html.gz

Fortnite Lite 3D

Prudence Malinki

MarkMonitor Inc.

edgeone.app


    // Game variables
    let scene, camera, renderer;
    let player, ground, glider;
    let enemies = [];
    let bullets = [];
    let trees = [];
    
    // Game phases
    let gamePhase = 'lobby'; // lobby, dropping, playing
    let dropAltitude = 100;
    let dropSpeed = 0.3;
    
    // Controls
    let keys = {};
    let joystickActive = false;
    let joystickDir = { x: 0, y: 0 };
    let mouseAngle = 0;
    let isFirstPerson = false;
    let isShooting = false;
    let shootCooldown = 0;
    
    // Game state
    const game = {
        health: 100,
        bullets: 30,
        maxBullets: 30,
        kills: 0,
        gameOver: false,
        stormTimer: 180,
        stormRadius: 50
    };

    // Play button
    document.getElementById('playButton').addEventListener('click', startGame);

    function startGame() {
        document.getElementById('lobby').style.display = 'none';
        gamePhase = 'dropping';
        document.getElementById('dropPhase').style.display = 'block';
        
        init();
        startDrop();
    }

    function startDrop() {
        // Position player high in the sky
        player.position.set(
            (Math.random() - 0.5) * 30,
            100,
            (Math.random() - 0.5) * 30
        );
        
        // Create glider
        const gliderGeo = new THREE.ConeGeometry(2, 0.5, 3);
        const gliderMat = new THREE.MeshLambertMaterial({ color: 0x00FFFF });
        glider = new THREE.Mesh(gliderGeo, gliderMat);
        glider.rotation.x = Math.PI;
        glider.position.y = 2;
        player.add(glider);
        
        // Camera for drop
        camera.position.set(player.position.x, player.position.y + 15, player.position.z + 20);
        camera.lookAt(player.position);
        
        // Show mobile controls during drop
        document.querySelectorAll('.mobile-controls').forEach(el => {
            el.style.display = 'block';
        });
    }

    function updateDrop() {
        if (gamePhase !== 'dropping') return;
        
        // Move player down
        player.position.y -= dropSpeed;
        dropAltitude = Math.max(0, player.position.y);
        
        // Player can steer while dropping
        let moveX = 0, moveZ = 0;
        
        if (keys['w'] || keys['arrowup']) moveZ -= 0.2;
        if (keys['s'] || keys['arrowdown']) moveZ += 0.2;
        if (keys['a'] || keys['arrowleft']) moveX -= 0.2;
        if (keys['d'] || keys['arrowright']) moveX += 0.2;
        
        moveX += joystickDir.x * 0.2;
        moveZ += joystickDir.y * 0.2;
        
        player.position.x += moveX;
        player.position.z += moveZ;
        
        // Keep in bounds
        const maxDist = 45;
        const dist = Math.sqrt(player.position.x * player.position.x + player.position.z * player.position.z);
        if (dist > maxDist) {
            player.position.x = (player.position.x / dist) * maxDist;
            player.position.z = (player.position.z / dist) * maxDist;
        }
        
        // Update camera
        camera.position.set(
            player.position.x,
            player.position.y + 15,
            player.position.z + 20
        );
        camera.lookAt(player.position);
        
        // Update UI
        document.getElementById('altitude').textContent = `Hoogte: ${Math.floor(dropAltitude)}m`;
        
        // Glider animation
        if (glider) {
            glider.rotation.z += 0.02;
        }
        
        // Land
        if (player.position.y <= 1) {
            player.position.y = 1;
            landPlayer();
        }
    }

    function landPlayer() {
        gamePhase = 'playing';
        
        // Remove glider
        if (glider) {
            player.remove(glider);
            glider = null;
        }
        
        // Hide drop screen
        document.getElementById('dropPhase').style.display = 'none';
        
        // Show game UI
        document.getElementById('crosshair').style.display = 'block';
        document.getElementById('hud').style.display = 'block';
        document.getElementById('healthBar').style.display = 'block';
        document.getElementById('ammo').style.display = 'block';
        document.getElementById('viewMode').style.display = 'block';
        
        // Spawn enemies
        for (let i = 0; i < 3; i++) {
            setTimeout(() => spawnEnemy(), i * 1000);
        }
        
        // Start timers
        startGameTimers();
    }

    function startGameTimers() {
        // Enemy spawner
        setInterval(() => {
            if (enemies.length < 8 && !game.gameOver && gamePhase === 'playing') {
                spawnEnemy();
            }
        }, 5000);
        
        // Storm timer
        setInterval(() => {
            if (!game.gameOver && game.stormTimer > 0 && gamePhase === 'playing') {
                game.stormTimer--;
                document.getElementById('timer').textContent = game.stormTimer;
            }
        }, 1000);
    }

    // Initialize Three.js scene
    function init() {
        try {
            // Scene setup
            scene = new THREE.Scene();
            scene.background = new THREE.Color(0x87CEEB);
            scene.fog = new THREE.Fog(0x87CEEB, 20, 80);
            
            // Camera
            camera = new THREE.PerspectiveCamera(
                75,
                window.innerWidth / window.innerHeight,
                0.1,
                1000
            );
            
            // Renderer
            const canvas = document.getElementById('gameCanvas');
            renderer = new THREE.WebGLRenderer({ 
                canvas: canvas,
                antialias: true 
            });
            renderer.setSize(window.innerWidth, window.innerHeight);
            renderer.shadowMap.enabled = true;
            renderer.shadowMap.type = THREE.PCFSoftShadowMap;
            
            // Lights
            const ambientLight = new THREE.AmbientLight(0xffffff, 0.7);
            scene.add(ambientLight);
            
            const dirLight = new THREE.DirectionalLight(0xffffff, 0.8);
            dirLight.position.set(20, 30, 20);
            dirLight.castShadow = true;
            dirLight.shadow.camera.left = -50;
            dirLight.shadow.camera.right = 50;
            dirLight.shadow.camera.top = 50;
            dirLight.shadow.camera.bottom = -50;
            dirLight.shadow.mapSize.width = 2048;
            dirLight.shadow.mapSize.height = 2048;
            scene.add(dirLight);
            
            // Ground
            const groundGeo = new THREE.PlaneGeometry(120, 120);
            const groundMat = new THREE.MeshLambertMaterial({ color: 0x7FB069 });
            ground = new THREE.Mesh(groundGeo, groundMat);
            ground.rotation.x = -Math.PI / 2;
            ground.receiveShadow = true;
            scene.add(ground);
            
            // Player
            const playerGeo = new THREE.BoxGeometry(1, 2, 1);
            const playerMat = new THREE.MeshLambertMaterial({ color: 0xFF6B35 });
            player = new THREE.Mesh(playerGeo, playerMat);
            player.position.set(0, 1, 0);
            player.castShadow = true;
            scene.add(player);
            
            // Add trees
            createTrees();
            
            // Storm circle
            const stormGeo = new THREE.RingGeometry(48, 50, 64);
            const stormMat = new THREE.MeshBasicMaterial({ 
                color: 0x8A2BE2,
                transparent: true,
                opacity: 0.4,
                side: THREE.DoubleSide
            });
            const stormMesh = new THREE.Mesh(stormGeo, stormMat);
            stormMesh.rotation.x = -Math.PI / 2;
            stormMesh.position.y = 0.1;
            scene.add(stormMesh);
            window.stormMesh = stormMesh;
            
            setupControls();
            animate();
            
            console.log('Game initialized successfully!');
        } catch (error) {
            console.error('Initialization error:', error);
            alert('Game kon niet laden. Herlaad de pagina.');
        }
    }

    function createTrees() {
        for (let i = 0; i < 20; i++) {
            const angle = Math.random() * Math.PI * 2;
            const dist = 15 + Math.random() * 30;
            
            const trunkGeo = new THREE.CylinderGeometry(0.4, 0.5, 5, 8);
            const trunkMat = new THREE.MeshLambertMaterial({ color: 0x8B4513 });
            const trunk = new THREE.Mesh(trunkGeo, trunkMat);
            
            trunk.position.set(
                Math.cos(angle) * dist,
                2.5,
                Math.sin(angle) * dist
            );
            trunk.castShadow = true;
            trunk.receiveShadow = true;
            
            scene.add(trunk);
            trees.push(trunk);
        }
    }

    function spawnEnemy() {
        const angle = Math.random() * Math.PI * 2;
        const dist = 25 + Math.random() * 20;
        
        const enemyGeo = new THREE.BoxGeometry(1, 2, 1);
        const enemyMat = new THREE.MeshLambertMaterial({ color: 0x8B4513 });
        const enemy = new THREE.Mesh(enemyGeo, enemyMat);
        
        enemy.position.set(
            Math.cos(angle) * dist,
            1,
            Math.sin(angle) * dist
        );
        enemy.castShadow = true;
        
        enemy.health = 100;
        enemy.maxHealth = 100;
        enemy.speed = 0.05 + Math.random() * 0.03;
        enemy.state = 'chase';
        enemy.stateTimer = 0;
        enemy.strafeDir = Math.random() > 0.5 ? 1 : -1;
        
        const barBg = new THREE.Mesh(
            new THREE.PlaneGeometry(1.2, 0.15),
            new THREE.MeshBasicMaterial({ color: 0x000000 })
        );
        barBg.position.y = 2.3;
        enemy.add(barBg);
        
        const barFill = new THREE.Mesh(
            new THREE.PlaneGeometry(1.2, 0.15),
            new THREE.MeshBasicMaterial({ color: 0x00ff00 })
        );
        barFill.position.y = 2.3;
        barFill.position.z = 0.01;
        enemy.add(barFill);
        
        enemy.healthBar = barFill;
        
        scene.add(enemy);
        enemies.push(enemy);
    }

    function setupControls() {
        window.addEventListener('keydown', e => {
            keys[e.key.toLowerCase()] = true;
            if (e.key.toLowerCase() === 'r' && gamePhase === 'playing') reload();
            if (e.key.toLowerCase() === 'v' && gamePhase === 'playing') toggleView();
        });
        
        window.addEventListener('keyup', e => {
            keys[e.key.toLowerCase()] = false;
        });
        
        const canvas = document.getElementById('gameCanvas');
        canvas.addEventListener('mousemove', e => {
            const rect = canvas.getBoundingClientRect();
            const x = e.clientX - rect.left;
            const y = e.clientY - rect.top;
            const centerX = rect.width / 2;
            const centerY = rect.height / 2;
            
            mouseAngle = Math.atan2(y - centerY, x - centerX);
        });
        
        canvas.addEventListener('mousedown', () => {
            if (gamePhase === 'playing') isShooting = true;
        });
        
        canvas.addEventListener('mouseup', () => {
            isShooting = false;
        });
        
        canvas.addEventListener('touchstart', e => {
            if (e.touches.length > 0 && gamePhase === 'playing') {
                const touch = e.touches[0];
                const rect = canvas.getBoundingClientRect();
                const x = touch.clientX - rect.left;
                const y = touch.clientY - rect.top;
                const centerX = rect.width / 2;
                const centerY = rect.height / 2;
                
                mouseAngle = Math.atan2(y - centerY, x - centerX);
            }
        });
        
        canvas.addEventListener('touchmove', e => {
            e.preventDefault();
            if (e.touches.length > 0) {
                const touch = e.touches[0];
                const rect = canvas.getBoundingClientRect();
                const x = touch.clientX - rect.left;
                const y = touch.clientY - rect.top;
                const centerX = rect.width / 2;
                const centerY = rect.height / 2;
                
                mouseAngle = Math.atan2(y - centerY, x - centerX);
            }
        });
        
        const joystickBase = document.getElementById('joystick');
        const stick = document.getElementById('stick');
        
        joystickBase.addEventListener('touchstart', e => {
            e.preventDefault();
            joystickActive = true;
            handleJoystick(e.touches[0]);
        });
        
        joystickBase.addEventListener('touchmove', e => {
            e.preventDefault();
            if (joystickActive) handleJoystick(e.touches[0]);
        });
        
        joystickBase.addEventListener('touchend', e => {
            e.preventDefault();
            joystickActive = false;
            joystickDir = { x: 0, y: 0 };
            stick.style.transform = 'translate(-50%, -50%)';
        });
        
        function handleJoystick(touch) {
            const rect = joystickBase.getBoundingClientRect();
            const centerX = rect.left + rect.width / 2;
            const centerY = rect.top + rect.height / 2;
            
            let dx = touch.clientX - centerX;
            let dy = touch.clientY - centerY;
            
            const dist = Math.sqrt(dx * dx + dy * dy);
            const maxDist = 40;
            
            if (dist > maxDist) {
                dx = (dx / dist) * maxDist;
                dy = (dy / dist) * maxDist;
            }
            
            joystickDir.x = dx / maxDist;
            joystickDir.y = dy / maxDist;
            
            stick.style.transform = `translate(calc(-50% + ${dx}px), calc(-50% + ${dy}px))`;
        }
        
        document.getElementById('shootBtn').addEventListener('touchstart', e => {
            e.preventDefault();
            if (gamePhase === 'playing') isShooting = true;
        });
        
        document.getElementById('shootBtn').addEventListener('touchend', e => {
            e.preventDefault();
            isShooting = false;
        });
        
        document.getElementById('reloadBtn').addEventListener('touchstart', e => {
            e.preventDefault();
            if (gamePhase === 'playing') reload();
        });
        
        document.getElementById('viewBtn').addEventListener('touchstart', e => {
            e.preventDefault();
            if (gamePhase === 'playing') toggleView();
        });
    }

    function toggleView() {
        isFirstPerson = !isFirstPerson;
        document.getElementById('viewMode').innerHTML = 
            isFirstPerson ? '📷 First Person<br>(V / 📷 knop)' : '📷 Third Person<br>(V / 📷 knop)';
    }

    function shoot() {
        if (game.bullets > 0 && !game.gameOver && shootCooldown <= 0) {
            game.bullets--;
            shootCooldown = 8;
            document.getElementById('bullets').textContent = game.bullets;
            
            const bulletGeo = new THREE.SphereGeometry(0.2, 8, 8);
            const bulletMat = new THREE.MeshBasicMaterial({ color: 0xFFD700 });
            const bullet = new THREE.Mesh(bulletGeo, bulletMat);
            
            bullet.position.copy(player.position);
            bullet.position.y = 1.5;
            
            const direction = new THREE.Vector3(
                Math.cos(mouseAngle),
                0,
                Math.sin(mouseAngle)
            );
            
            bullet.velocity = direction.multiplyScalar(0.8);
            
            scene.add(bullet);
            bullets.push(bullet);
        }
    }

    function reload() {
        if (!game.gameOver) {
            game.bullets = game.maxBullets;
            document.getElementById('bullets').textContent = game.bullets;
        }
    }

    function takeDamage(amount) {
        game.health = Math.max(0, game.health - amount);
        const healthPercent = game.health / 100;
        document.getElementById('healthFill').style.width = (healthPercent * 100) + '%';
        document.getElementById('healthText').textContent = Math.floor(game.health);
        
        if (game.health <= 0 && !game.gameOver) {
            endGame(false);
        }
    }

    function updateEnemyAI(enemy) {
        const distToPlayer = enemy.position.distanceTo(player.position);
        
        enemy.stateTimer++;
        
        if (distToPlayer < 5 && enemy.health < 40) {
            enemy.
```

Requests	IP Address	Location	AS Autonomous System
2	104.17.24.14	United States	AS13335Cloudflare, Inc.
1	43.152.26.58	Singapore	AS139341ACE
3	2	-	-

Security Scan Report: aggressive-blush-5xmks1yoqv-46abtion77.edgeone.app

Summary

AI Security Verdict

Moderate Risk

Risk Factors

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

Detected Technologies3

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