documentation technical

English

The domain 'agricultural-plum-niuapb8e21-dxu4fk1ad8.edgeone.app' uses the application-focused generic top-level domain (.app) with subdomain 'agricultural-plum-niuapb8e21-dxu4fk1ad8'. Its registrable label 'edgeone' stretches across 7 characters with four vowels and 3 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/ca/48/ca48f04b-c4f5-4cfe-92d4-a28b064f85c1.html.gz

sha256=:MTIDlXGXgAod+pVM/ehBA74SvNjjOu7ge+BCFgArLm0=:

313203957197800a1dfa954cfde84103be12bcd8e33aeee07be04216002b2e6d

54f42f545b51c42cfa6e25496169ef59ad887f3d57f7430f0e827c64ca9a39f5

html/ca/48/ca48f04b-c4f5-4cfe-92d4-a28b064f85c1_nodriver.html.gz

Hyper-Shift: 4D Maze

Prudence Malinki

MarkMonitor Inc.

edgeone.app


    import * as THREE from 'https://unpkg.com/three@0.158.0/build/three.module.js';

    // --- CONFIGURATION ---
    const HYPERCUBE_SIZE = 30;
    const PLAYER_SPEED = 0.8;
    const ROTATION_SPEED = 0.03;
    
    // --- SETUP SCENE ---
    const scene = new THREE.Scene();
    scene.fog = new THREE.FogExp2(0x050505, 0.015);

    const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
    camera.position.z = 60;
    camera.position.y = 20;
    camera.lookAt(0, 0, 0);

    const renderer = new THREE.WebGLRenderer({ antialias: true });
    renderer.setSize(window.innerWidth, window.innerHeight);
    document.body.appendChild(renderer.domElement);

    // --- 4D MATH HELPERS ---
    // A 4D point is {x, y, z, w}
    class Point4D {
        constructor(x, y, z, w) {
            this.x = x; this.y = y; this.z = z; this.w = w;
        }
    }

    // Generate the 16 vertices of a Tesseract
    let points = [];
    for (let i = 0; i < 16; i++) {
        let x = (i & 1) ? 1 : -1;
        let y = (i & 2) ? 1 : -1;
        let z = (i & 4) ? 1 : -1;
        let w = (i & 8) ? 1 : -1;
        points.push(new Point4D(x * HYPERCUBE_SIZE, y * HYPERCUBE_SIZE, z * HYPERCUBE_SIZE, w * HYPERCUBE_SIZE));
    }

    // Define connections (edges) of a Tesseract
    const edges = [];
    for (let i = 0; i < 16; i++) {
        for (let j = i + 1; j < 16; j++) {
            // Count how many bits differ. If exactly 1 bit differs, they are connected.
            let diff = 0;
            for (let k = 0; k < 4; k++) {
                if (((i >> k) & 1) !== ((j >> k) & 1)) diff++;
            }
            if (diff === 1) edges.push([i, j]);
        }
    }

    // --- VISUALS ---
    // Create a LineSegments object for the Tesseract
    const geometry = new THREE.BufferGeometry();
    const positions = new Float32Array(edges.length * 2 * 3); // 2 points per edge, 3 coords per point
    geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));

    const material = new THREE.LineBasicMaterial({ color: 0x00ffff, transparent: true, opacity: 0.3 });
    const tesseractMesh = new THREE.LineSegments(geometry, material);
    scene.add(tesseractMesh);

    // Add "Obstacles" (Red walls inside specific cells)
    const obstacles = [];
    const obstacleGeo = new THREE.BoxGeometry(10, 10, 10);
    const obstacleMat = new THREE.MeshBasicMaterial({ color: 0xff0055, wireframe: true, transparent: true, opacity: 0.5 });
    
    // Create 3 random obstacles
    for(let i=0; i<3; i++) {
        const obs = new THREE.Mesh(obstacleGeo, obstacleMat);
        // Place them somewhat randomly but within bounds
        obs.position.set((Math.random()-0.5)*40, (Math.random()-0.5)*40, (Math.random()-0.5)*40);
        scene.add(obs);
        obstacles.push(obs);
    }

    // Add Target
    const targetGeo = new THREE.IcosahedronGeometry(3, 0);
    const targetMat = new THREE.MeshBasicMaterial({ color: 0x00ff00, wireframe: true });
    const target = new THREE.Mesh(targetGeo, targetMat);
    target.position.set(20, 20, 20); // Fixed target location
    scene.add(target);

    // Add Player
    const playerGeo = new THREE.SphereGeometry(2, 16, 16);
    const playerMat = new THREE.MeshBasicMaterial({ color: 0xffffff });
    const player = new THREE.Mesh(playerGeo, playerMat);
    scene.add(player);

    // Add a point light to the player
    const light = new THREE.PointLight(0xffffff, 1, 100);
    player.add(light);

    // --- GAME STATE ---
    let angleXW = 0; // The 4D rotation angle
    let keys = { w: false, a: false, s: false, d: false, space: false };
    let isRotating = false;

    // --- INPUT HANDLING ---
    window.addEventListener('keydown', (e) => {
        if (e.code === 'KeyW') keys.w = true;
        if (e.code === 'KeyS') keys.s = true;
        if (e.code === 'KeyA') keys.a = true;
        if (e.code === 'KeyD') keys.d = true;
        if (e.code === 'Space') {
            if(!isRotating) {
                isRotating = true;
                document.getElementById('status').innerText = "ROTATING 4TH DIMENSION...";
                document.getElementById('status').style.color = "#ffff00";
            }
        }
    });

    window.addEventListener('keyup', (e) => {
        if (e.code === 'KeyW') keys.w = false;
        if (e.code === 'KeyS') keys.s = false;
        if (e.code === 'KeyA') keys.a = false;
        if (e.code === 'KeyD') keys.d = false;
        if (e.code === 'Space') {
            isRotating = false;
            document.getElementById('status').innerText = "OBJECTIVE: REACH THE GREEN CORE";
            document.getElementById('status').style.color = "#ff00ff";
        }
    });

    // --- 4D PROJECTION FUNCTION ---
    function project4D(point, angle) {
        // 1. Rotate around XW plane (The 4D Rotation)
        let x = point.x * Math.cos(angle) - point.w * Math.sin(angle);
        let w = point.x * Math.sin(angle) + point.w * Math.cos(angle);
        let y = point.y;
        let z = point.z;

        // 2. Perspective Projection from 4D to 3D
        // The further away in W, the smaller the object appears in 3D
        let distance = 4; // Camera distance in 4D
        let scale = distance / (distance - w); 
        
        let x3 = x * scale;
        let y3 = y * scale;
        let z3 = z * scale;

        return new THREE.Vector3(x3, y3, z3);
    }

    // --- GAME LOOP ---
    function animate() {
        requestAnimationFrame(animate);

        // 1. Handle 4D Rotation
        if (isRotating) {
            angleXW += ROTATION_SPEED;
        }

        // 2. Update Tesseract Geometry based on 4D rotation
        const positions = tesseractMesh.geometry.attributes.position.array;
        let idx = 0;
        
        // We project all 16 points first
        let projectedPoints = points.map(p => project4D(p, angleXW));

        // Then map edges to the line buffer
        edges.forEach(edge => {
            let p1 = projectedPoints[edge[0]];
            let p2 = projectedPoints[edge[1]];

            positions[idx++] = p1.x; positions[idx++] = p1.y; positions[idx++] = p1.z;
            positions[idx++] = p2.x; positions[idx++] = p2.y; positions[idx++] = p2.z;
        });
        
        tesseractMesh.geometry.attributes.position.needsUpdate = true;

        // 3. Player Movement (Simple 3D movement inside the projected space)
        // Note: In a true 4D game, you'd move in W too, but for playability we stick to XYZ movement
        // while the world warps around you.
        if (keys.w) player.position.z -= PLAYER_SPEED;
        if (keys.s) player.position.z += PLAYER_SPEED;
        if (keys.a) player.position.x -= PLAYER_SPEED;
        if (keys.d) player.position.x += PLAYER_SPEED;

        // Camera follow
        camera.position.x += (player.position.x - camera.position.x) * 0.05;
        camera.position.z += (player.position.z + 40 - camera.position.z) * 0.05;
        camera.lookAt(player.position);

        // 4. Rotate Obstacles and Target to match the 4D vibe
        target.rotation.y += 0.02;
        target.rotation.x += 0.01;
        
        obstacles.forEach(obs => {
            obs.rotation.x += 0.01;
            obs.rotation.y += 0.01;
        });

        // 5. Collision Detection (Simple distance check)
        const distToTarget = player.position.distanceTo(target.position);
        if (distToTarget < 5) {
            document.getElementById('status').innerText = "DIMENSION REACHED! (Refresh to Restart)";
            document.getElementById('status').style.color = "#00ff00";
            target.scale.setScalar(2); // Grow target
        }

        renderer.render(scene, camera);
    }

    // Handle Resize
    window.addEventListener('resize', () => {
        camera.aspect = window.innerWidth / window.innerHeight;
        camera.updateProjectionMatrix();
        renderer.setSize(window.innerWidth, window.innerHeight);
    });

    animate();


✅ Low Risk - https://agricultural-plum-niuapb8e21-dxu4fk1ad8.edgeone.app/

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

Security Scan Report: agricultural-plum-niuapb8e21-dxu4fk1ad8.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