technology software

cryptocurrency blockchain

documentation technical

adult content

news media journalism

English

Within the application-focused generic top-level domain (.app), 'running-rose-oy0atbvdyn-4vuxjxtszd.edgeone.app' is registered with subdomain 'running-rose-oy0atbvdyn-4vuxjxtszd'. Count 7 characters in 'edgeone' containing 4 vowels alongside three consonants. It segments into two words: edge, one. Average segment length settles at 3.5 characters. No strong language cues emerged from the frequency lists.

html/cc/4b/cc4bd07d-1229-41cd-af9d-95d70ed2d7c6.html.gz

99b9fb0ac1668ee5aee7cc13fb76eca3a6f928bdf1223c68dbd24fda5e30ced7

9274bbcec8d96168626c732b5d31c775aa8cfb7eaa0599bec0c175908a2c1ce2

48b3f3320f0c72e286756bb160a331e7390001d55254c57078f448ffd9601df3

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

viewport

html/cc/4b/cc4bd07d-1229-41cd-af9d-95d70ed2d7c6_nodriver.html.gz

running-rose-oy0atbvdyn-4vuxjxtszd.edgeone.app

Prudence Malinki

MarkMonitor Inc.

edgeone.app

IRT-SG-ACE

ACE administrator

ACE-SG


// --- GENERATE TEXTURES INTERNALLY (NO MORE BROKEN IMAGES) ---
function createTexture(type) {
    const cvs = document.createElement('canvas');
    cvs.width = 256; cvs.height = 256;
    const ctx = cvs.getContext('2d');

    if(type === 'floor') {
        ctx.fillStyle = '#555'; ctx.fillRect(0,0,256,256);
        ctx.fillStyle = '#444'; ctx.fillRect(0,0,128,128); ctx.fillRect(128,128,128,128); // Checkers
        ctx.strokeStyle = '#333'; ctx.lineWidth = 4; ctx.strokeRect(0,0,256,256); // Border
        // Noise
        for(let i=0; i<1000; i++) {
            ctx.fillStyle = Math.random()>0.5 ? 'rgba(255,255,255,0.05)' : 'rgba(0,0,0,0.05)';
            ctx.fillRect(Math.random()*256, Math.random()*256, 4, 4);
        }
    } 
    else if(type === 'wall') {
        ctx.fillStyle = '#3a3a3a'; ctx.fillRect(0,0,256,256);
        ctx.fillStyle = '#555';
        // Bricks
        for(let i=0; i<8; i++) {
            for(let j=0; j<4; j++) {
                let off = (j%2)*32;
                ctx.fillRect(i*64 - off + 2, j*64 + 2, 60, 60);
            }
        }
    }
    else if(type === 'block') {
        ctx.fillStyle = '#8B4513'; ctx.fillRect(0,0,256,256); // Wood color
        ctx.strokeStyle = '#5c2e0b'; ctx.lineWidth = 10; ctx.strokeRect(5,5,246,246);
        ctx.fillStyle = '#a0522d'; ctx.fillRect(20,20,216,216); // Inner wood
        ctx.font = "bold 60px Arial"; ctx.fillStyle = "rgba(0,0,0,0.2)"; ctx.textAlign="center"; ctx.fillText("X", 128, 150);
    }
    else if(type === 'door') {
        ctx.fillStyle = '#222'; ctx.fillRect(0,0,256,256);
        ctx.fillStyle = '#0f0'; ctx.fillRect(20,20,216,216); // Neon Green center
        ctx.fillStyle = '#000'; ctx.font = "bold 40px monospace"; ctx.textAlign="center"; ctx.fillText("EXIT", 128, 140);
    }

    const tex = new THREE.CanvasTexture(cvs);
    tex.magFilter = THREE.NearestFilter; // Minecraft chunky look
    return tex;
}

// --- GAME VARIABLES ---
const GRID_SIZE = 14;
const CELL_SIZE = 4; // Bigger blocks
const MAP_OFFSET = (GRID_SIZE * CELL_SIZE) / 2;

let scene, camera, renderer, raycaster;
let phase = 'BUILD';
let timeLeft = 120;
let grid = [];
let meshes = []; // All placeable blocks
let boundaries = []; // Collision boxes

// Player
let camPitch = 0, camYaw = 0;
let moveInput = { x: 0, z: 0 };
let velocity = new THREE.Vector3();
let isGrounded = false;
let bobTimer = 0;

// Input State
let isTouchingJoystick = false;
let breakTimer = null;
let breakStartTime = 0;
let activeBlock = null;

// Init
function init() {
    // 1. Scene
    scene = new THREE.Scene();
    scene.background = new THREE.Color(0x87CEEB); // Sky Blue
    scene.fog = new THREE.Fog(0x87CEEB, 20, 80);

    // 2. Camera
    camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
    camera.position.set(-MAP_OFFSET + 4, 4, -MAP_OFFSET + 4); // Start at corner
    
    // 3. Renderer
    renderer = new THREE.WebGLRenderer({ antialias: true });
    renderer.setSize(window.innerWidth, window.innerHeight);
    renderer.shadowMap.enabled = true;
    document.body.appendChild(renderer.domElement);

    // 4. Lights
    const hemiLight = new THREE.HemisphereLight(0xffffff, 0x444444, 0.8);
    scene.add(hemiLight);
    
    const dirLight = new THREE.DirectionalLight(0xffffff, 0.7);
    dirLight.position.set(50, 100, 50);
    dirLight.castShadow = true;
    dirLight.shadow.mapSize.width = 2048;
    dirLight.shadow.mapSize.height = 2048;
    scene.add(dirLight);

    // 5. Build World
    buildLevel();
    
    // 6. Inputs
    setupControls();

    // 7. Loop
    requestAnimationFrame(animate);
    setInterval(gameTimer, 1000);
    
    // Fix resize
    window.addEventListener('resize', () => {
        camera.aspect = window.innerWidth / window.innerHeight;
        camera.updateProjectionMatrix();
        renderer.setSize(window.innerWidth, window.innerHeight);
    });
}

function buildLevel() {
    // Floor (Procedural Tiling)
    const floorTex = createTexture('floor');
    floorTex.wrapS = floorTex.wrapT = THREE.RepeatWrapping;
    floorTex.repeat.set(GRID_SIZE, GRID_SIZE);
    
    const floorGeo = new THREE.PlaneGeometry(GRID_SIZE*CELL_SIZE, GRID_SIZE*CELL_SIZE);
    const floorMat = new THREE.MeshStandardMaterial({ map: floorTex });
    const floor = new THREE.Mesh(floorGeo, floorMat);
    floor.rotation.x = -Math.PI/2;
    floor.receiveShadow = true;
    floor.name = "floor";
    scene.add(floor);

    // Walls
    const wallTex = createTexture('wall');
    wallTex.wrapS = wallTex.wrapT = THREE.RepeatWrapping;
    wallTex.repeat.set(GRID_SIZE, 1);
    
    const h = 10;
    const wallMat = new THREE.MeshStandardMaterial({ map: wallTex });
    
    // Create 4 Walls
    const wallGeo = new THREE.BoxGeometry(GRID_SIZE*CELL_SIZE, h, 2);
    const w1 = new THREE.Mesh(wallGeo, wallMat); w1.position.set(0, h/2, -MAP_OFFSET-1);
    const w2 = new THREE.Mesh(wallGeo, wallMat); w2.position.set(0, h/2, MAP_OFFSET+1);
    const w3 = new THREE.Mesh(new THREE.BoxGeometry(2, h, GRID_SIZE*CELL_SIZE), wallMat); w3.position.set(-MAP_OFFSET-1, h/2, 0);
    const w4 = new THREE.Mesh(new THREE.BoxGeometry(2, h, GRID_SIZE*CELL_SIZE), wallMat); w4.position.set(MAP_OFFSET+1, h/2, 0);
    
    scene.add(w1, w2, w3, w4);
    [w1,w2,w3,w4].forEach(w => boundaries.push(new THREE.Box3().setFromObject(w)));

    // Grid Data
    for(let x=0; x<GRID_SIZE; x++) {
        grid[x] = [];
        for(let z=0; z<GRID_SIZE; z++) grid[x][z] = 0;
    }

    // Start & End Zones
    createZone(0, 0, "START", 0x00ff00);
    createZone(GRID_SIZE-1, GRID_SIZE-1, "EXIT", 0xff0000);
}

function createZone(gx, gz, text, color) {
    grid[gx][gz] = 2; // Reserved
    const x = gx * CELL_SIZE - MAP_OFFSET + CELL_SIZE/2;
    const z = gz * CELL_SIZE - MAP_OFFSET + CELL_SIZE/2;
    
    const pad = new THREE.Mesh(
        new THREE.BoxGeometry(CELL_SIZE, 0.2, CELL_SIZE),
        new THREE.MeshBasicMaterial({ color: color, opacity: 0.5, transparent: true })
    );
    pad.position.set(x, 0.1, z);
    scene.add(pad);
}

// --- CONTROLS ---
function setupControls() {
    // 1. Joystick
    const joyZone = document.getElementById('joystick-zone');
    const joystick = nipplejs.create({ 
        zone: joyZone, mode: 'static', position: {left: '50%', top: '50%'}, color: 'white', size: 100 
    });
    
    joystick.on('start', () => { isTouchingJoystick = true; });
    joystick.on('move', (evt, data) => {
        // Correct Mapping: Y is Forward/Back (Z), X is Left/Right (X)
        moveInput.z = data.vector.y; 
        moveInput.x = data.vector.x;
    });
    joystick.on('end', () => { 
        isTouchingJoystick = false; 
        moveInput = {x:0, z:0}; 
    });

    // 2. Camera Look (Right half of screen)
    let lastX = 0, lastY = 0;
    window.addEventListener('touchstart', e => {
        if(e.target.closest('button') || e.target.closest('#joystick-zone')) return;
        lastX = e.touches[0].pageX;
        lastY = e.touches[0].pageY;
        
        // Check for block breaking
        checkBreakStart();
    }, {passive: false});

    window.addEventListener('touchmove', e => {
        if(e.target.closest('#joystick-zone')) return;
        
        const dx = e.touches[0].pageX - lastX;
        const dy = e.touches[0].pageY - lastY;
        
        // If moving significantly, it's a look action, cancel break
        if(Math.abs(dx) > 2 || Math.abs(dy) > 2) {
            cancelBreak();
            camYaw -= dx * 0.005;
            camPitch -= dy * 0.003;
            camPitch = Math.max(-1.5, Math.min(1.5, camPitch)); // Clamp look up/down
        }
        
        lastX = e.touches[0].pageX;
        lastY = e.touches[0].pageY;
    }, {passive: false});

    window.addEventListener('touchend', e => {
        if(breakTimer) {
            cancelBreak(); // If we let go early, cancel break
        } else if(!isTouchingJoystick && phase === 'BUILD' && !e.target.closest('button')) {
            // It was a quick tap -> Place Block
            attemptPlaceBlock(); 
        }
    });

    // 3. Jump
    document.getElementById('jump-btn').addEventListener('touchstart', (e) => {
        e.preventDefault();
        if(isGrounded) {
            velocity.y = 12; // Jump force
            isGrounded = false;
        }
    });

    // 4. Done Button
    document.getElementById('done-btn').addEventListener('click', () => {
        if(confirm("Finish Maze and Start AI?")) {
            startAI();
        }
    });
}

// --- LOGIC: PLACING & BREAKING ---

function attemptPlaceBlock() {
    raycaster = new THREE.Raycaster();
    raycaster.setFromCamera(new THREE.Vector2(0,0), camera);
    const intersects = raycaster.intersectObjects(scene.children);
    
    // Filter for valid hits
    let hit = intersects.find(i => i.object.name === 'floor' || i.object.name === 'block');
    
    if(hit && hit.distance < 15) { // Range check
        // Calculate grid position based on normal
        const pos = new THREE.Vector3().copy(hit.point).add(hit.face.normal.multiplyScalar(CELL_SIZE/2));
        
        const gx = Math.floor((pos.x + MAP_OFFSET) / CELL_SIZE);
        const gz = Math.floor((pos.z + MAP_OFFSET) / CELL_SIZE);
        
        if(gx >= 0 && gx < GRID_SIZE && gz >= 0 && gz < GRID_SIZE) {
            // 1. Check if occupied
            if(grid[gx][gz] !== 0) return showMsg("Can't place here!");
            
            // 2. Check collision with player
            const blockBox = new THREE.Box3();
            blockBox.setFromCenterAndSize(
                new THREE.Vector3(gx*CELL_SIZE-MAP_OFFSET+CELL_SIZE/2, CELL_SIZE/2, gz*CELL_SIZE-MAP_OFFSET+CELL_SIZE/2),
                new THREE.Vector3(CELL_SIZE, CELL_SIZE, CELL_SIZE)
            );
            const playerBox = new THREE.Box3().setFromCenterAndSize(camera.position, new THREE.Vector3(1, 2, 1));
            if(blockBox.intersectsBox(playerBox)) return showMsg("You are standing there!");

            // 3. Check Path (The Anti-Cheat)
            grid[gx][gz] = 1; // Temporarily place
            if(!checkPathExists()) {
                grid[gx][gz] = 0; // Revert
                return showMsg("CANNOT BLOCK THE PATH!");
            }
            
            // 4. Place it
            placeBlockMesh(gx, gz);
        }
    }
}

function placeBlockMesh(gx, gz) {
    const geo = new THREE.BoxGeometry(CELL_SIZE, CELL_SIZE, CELL_SIZE);
    const mat = new THREE.MeshStandardMaterial({ map: createTexture('block') });
    const mesh = new THREE.Mesh(geo, mat);
    
    mesh.position.set(
        gx * CELL_SIZE - MAP_OFFSET + CELL_SIZE/2,
        CELL_SIZE/2,
        gz * CELL_SIZE - MAP_OFFSET + CELL_SIZE/2
    );
    mesh.castShadow = true;
    mesh.receiveShadow = true;
    mesh.name = "block";
    mesh.gX = gx; mesh.gZ = gz;
    
    scene.add(mesh);
    meshes.push(mesh);
    boundaries.push(new THREE.Box3().setFromObject(mesh));
}

function checkBreakStart() {
    raycaster = new THREE.Raycaster();
    raycaster.setFromCamera(new THREE.Vector2(0,0), camera);
    const intersects = raycaster.intersectObjects(meshes);
    
    if(intersects.length > 0 && intersects[0].distance < 15) {
        activeBlock = intersects[0].object;
        const bar = document.getElementById('break-progress');
        bar.style.display = 'block';
        bar.style.width = '0px';
        
        let width = 0;
        breakTimer = setInterval(() => {
            width += 5;
            bar.style.width = width + 'px';
            if(width >= 100) {
                removeBlock(activeBlock);
                cancelBreak();
            }
        }, 20); // 400ms to break
    }
}

function cancelBreak() {
    clearInterval(breakTimer);
    breakTimer = null;
    activeBlock = null;
    document.getElementById('break-progress').style.display = 'none';
}

function removeBlock(mesh) {
    scene.remove(mesh);
    grid[mesh.gX][mesh.gZ] = 0;
    meshes = meshes.filter(m => m !== mesh);
    
    // Rebuild boundaries
    boundaries = boundaries.filter(b => !b.containsPoint(mesh.position));
}

// --- PHYSICS & MOVEMENT ---

function animate() {
    requestAnimationFrame(animate);

    // 1. Camera Rotation
    camera.rotation.order = "YXZ";
    camera.rotation.y = camYaw;
    camera.rotation.x = camPitch;

    // 2. Physics Step
    const dt = 0.016;
    
    // Calculate Move Vector based on Camera Direction
    const forward = new THREE.Vector3(0, 0, -1).applyAxisAngle(new THREE.Vector3(0,1,0), camYaw);
    const right = new THREE.Vector3(1, 0, 0).applyAxisAngle(new THREE.Vector3(0,1,0), camYaw);
    
    const moveDir = new THREE.Vector3()
        .addScaledVector(forward, moveInput.z)
        .addScaledVector(right, moveInput.x)
        .normalize();

    // Apply movement to Velocity X/Z
    const speed = 10;
    velocity.x = moveDir.x * speed;
    velocity.z = moveDir.z * speed;
    
    // Gravity
    velocity.y -= 30 * dt; 
    
    // 3. Collision Detection (Simple AABB)
    const proposedPos = camera.position.clone().add(velocity.clone().multiplyScalar(dt));
    
    // Floor Collision
    if(proposedPos.y < 2) {
        proposedPos.y = 2;
        velocity.y = 0;
        isGrounded = true;
    }

    // Wall/Block Collision
    const playerBox = new THREE.Box3().setFromCenterAndSize(proposedPos, new THREE.Vector3(1, 2, 1));
    let collided = false;
    
    for(let b of boundaries) {
        if(playerBox.intersectsBox(b)) {
            collided = true;
            break;
        }
    }

    if(!collided) {
        camera.position.copy(proposedPos);
        
        // Head Bob
        if(moveInput.x !== 0 || moveInput.z !== 0) {
            bobTimer += 10 * dt;
            camera.position.y += Math.sin(bobTimer) * 0.1;
        }
    } else {
        // Slide against wall (simplified: just cancel X/Z movement but keep Y)
        camera.position.y = proposedPos.y; 
    }

    renderer.render(scene, camera);
}

// --- UTILS ---
function checkPathExists() {
    // BFS from 0,0 to End
    let q = [{x:0, z:0}];
    let visited = new Set(["0,0"]);
    
    while(q.length > 0) {
        let curr = q.shift();
        if(curr.x === GRID_SIZE-1 && curr.z === GRID_SIZE-1) return true;
        
        const dirs = [[0,1], [0,-1], [1,0], [-1,0]];
        for(let d of dirs) {
            let nx = curr.x + d[0];
            let nz = curr.z + d[1];
            
            if(nx>=0 && nx<GRID_SIZE && nz>=0 && nz<GRID_SIZE) {
                if(grid[nx][nz] !== 1 && !visited.has(`${nx},${nz}`)) {
                    visited.add(`${nx},${nz}`);
                    q.push({x:nx, z:nz});
                }
            }
        }
    }
    return false;
}

function showMsg(txt) {
    const el = document.getElementById('msg-box');
    el.innerText = txt;
    el.style.display = 'block';
    setTimeout(() => el.style.display = 'none', 2000);
}

function gameTimer() {
    if(phase === 'BUILD') {
        timeLeft--;
        const m = Math.floor(timeLeft / 60);
        const s = timeLeft % 60;
        document.getElementById('timer-box').innerText = `${m}:${s < 10 ? '0'+s : s}`;
        if(timeLeft <= 0) startAI();
    }
}

function startAI() {
    phase = 'ESCAPE';
    alert("AI RELEASED! (Logic Placeholder - You Win)");
    location.reload();
}

// Start
window.onload = init;



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

Security Scan Report: running-rose-oy0atbvdyn-4vuxjxtszd.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

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