entertainment media

documentation technical

gambling betting

adult content

Chinese

Domain 'secondary-red-rsmcgm6go3-5en62d91q9.edgeone.app' uses the application-focused generic top-level domain (.app); it also runs on subdomain 'secondary-red-rsmcgm6go3-5en62d91q9'. Count 7 characters in 'edgeone' with 4 vowels and 3 consonants. Breaking it apart gives two words: edge, one. The median word length lands at 3.5 characters. No strong language cues emerged from the frequency lists.

html/46/32/4632c8cd-2337-49a7-8444-b0c6af3b0b34.html.gz

50c20a7cb82420d0d94ce3875e95a94755cf8bdae2a44962c3f0af21bab2dd5d

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

viewport

apple-mobile-web-app-capable

apple-mobile-web-app-status-bar-style

apple-mobile-web-app-title

html/46/32/4632c8cd-2337-49a7-8444-b0c6af3b0b34_nodriver.html.gz

暴走弹球 - 肉鸽进阶版

Prudence Malinki

MarkMonitor Inc.

edgeone.app


/**
 * 《暴走弹球》iOS优化版
 * 适配刘海屏、禁止Safari默认手势、优化触控体验
 */
const canvas = document.getElementById('gameCanvas');
const ctx = canvas.getContext('2d');
 
// --- 游戏配置 ---
const CONFIG = {
    BALL_RADIUS: 8,
    BLOCK_COLS: 6,
    BLOCK_PADDING: 4,
    BALL_SPEED: 12,
    LAUNCH_ZONE_RATIO: 1/6,
    ITEM_TYPE: { BOMB: 'bomb', VORTEX: 'vortex', SKILL_FRUIT: 'skill_fruit' }
};
 
// --- 肉鸽技能库 ---
const SKILLS = [
    { id: 'split_1', name: '分身 I', desc: '发射数量 +1', effect: (g) => { g.ballCount += 1; } },
    { id: 'split_2', name: '分身 II', desc: '发射数量 +2', effect: (g) => { g.ballCount += 2; } },
    { id: 'split_3', name: '分身 III', desc: '发射数量 +3', effect: (g) => { g.ballCount += 3; } },
    { id: 'exp_1', name: '爆炸加倍 I', desc: '炸弹伤害 +1', effect: (g) => { g.explosionDamage += 1; } },
    { id: 'exp_2', name: '爆炸加倍 II', desc: '炸弹伤害 +2', effect: (g) => { g.explosionDamage += 2; } },
    { id: 'exp_3', name: '爆炸加倍 III', desc: '炸弹伤害 +3', effect: (g) => { g.explosionDamage += 3; } },
    { id: 'bounce_1', name: '弹性增强 I', desc: '最大弹跳次数 +3', effect: (g) => { g.maxBounces += 3; } },
    { id: 'damage_1', name: '威力弹头 I', desc: '伤害 +1', effect: (g) => { g.ballDamage += 1; } },
    { id: 'speed', name: '加速齿轮', desc: '飞行速度提升', effect: (g) => { CONFIG.BALL_SPEED += 2; } }
];
 
// --- 游戏核心 ---
const game = {
    width: 0, 
    height: 0,
    safeLineY: 0,
    canvasRect: null,
    
    // 游戏对象
    balls: [],
    blocks: [], 
    items: [], 
    particles: [],
    
    // 状态
    score: 0,
    level: 1,
    maxBounces: 5,
    ballDamage: 1,
    ballCount: 1,
    explosionDamage: 1,
    
    // 控制状态
    isAiming: false,
    isShooting: false,
    isChoosing: false,
    aimPos: { x: 0, y: 0 },
    shootPos: { x: 0, y: 0 },
    
    bestScore: 0,
 
    init() {
        this.resize();
        window.addEventListener('resize', () => this.resize());
        
        // 触控事件绑定
        canvas.addEventListener('mousedown', (e) => this.onInputStart(e));
        canvas.addEventListener('mousemove', (e) => this.onInputMove(e));
        canvas.addEventListener('mouseup', () => this.onInputEnd());
        
        // 移动端事件优化
        canvas.addEventListener('touchstart', (e) => { e.preventDefault(); this.onInputStart(e.touches[0]); }, {passive: false});
        canvas.addEventListener('touchmove', (e) => { e.preventDefault(); this.onInputMove(e.touches[0]); }, {passive: false});
        canvas.addEventListener('touchend', (e) => { e.preventDefault(); this.onInputEnd(); }, {passive: false});
 
        this.loadBestScore();
        this.startGame();
        this.loop();
    },
 
    resize() {
        const dpr = window.devicePixelRatio || 1;
        const rect = canvas.getBoundingClientRect();
        this.canvasRect = rect; 
        canvas.width = rect.width * dpr;
        canvas.height = rect.height * dpr;
        ctx.scale(dpr, dpr);
        
        this.width = rect.width;
        this.height = rect.height;
        // 安全线位置计算（基于画布实际高度）
        this.safeLineY = this.height * (1 - CONFIG.LAUNCH_ZONE_RATIO);
        this.shootPos = { x: this.width / 2, y: this.safeLineY };
    },
 
    startGame() {
        this.score = 0;
        this.level = 1;
        this.maxBounces = 5;
        this.ballDamage = 1;
        this.ballCount = 1;
        this.explosionDamage = 1;
        CONFIG.BALL_SPEED = 12;
        
        this.balls = [];
        this.blocks = [];
        this.items = [];
        this.particles = [];
        this.isShooting = false;
        this.isChoosing = false;
        
        this.updateUI();
        this.generateBlocks(true);
    },
 
    restart() {
        document.getElementById('gameOverModal').style.display = 'none';
        this.startGame();
    },
 
    getPos(e) {
        return { x: e.clientX - this.canvasRect.left, y: e.clientY - this.canvasRect.top };
    },
    onInputStart(e) {
        if (this.isShooting || this.isChoosing) return;
        const pos = this.getPos(e);
        if (pos.y > this.safeLineY) {
            this.isAiming = true;
            this.aimPos = pos;
        }
    },
    onInputMove(e) {
        if (!this.isAiming) return;
        this.aimPos = this.getPos(e);
    },
    onInputEnd() {
        if (!this.isAiming) return;
        this.isAiming = false;
        
        const dx = this.shootPos.x - this.aimPos.x;
        const dy = this.shootPos.y - this.aimPos.y;
        let dist = Math.sqrt(dx*dx + dy*dy);
 
        if (dist < 20) { this.launchBalls(0, -1); return; }
        if (dy > 0) { dy = -1; dx = dx > 0 ? 1 : -1; dist = 1; }
        
        this.launchBalls(dx / dist, dy / dist);
    },
 
    launchBalls(vx, vy) {
        const baseAngle = Math.atan2(vy, vx);
        const spread = Math.PI / 12; 
        const count = Math.max(1, this.ballCount);
        
        for (let i = 0; i < count; i++) {
            let angle = baseAngle;
            if (count > 1) {
                const step = spread / (count - 1);
                angle = baseAngle - (spread / 2) + (step * i);
            }
            
            const normVx = Math.cos(angle) * CONFIG.BALL_SPEED;
            const normVy = Math.sin(angle) * CONFIG.BALL_SPEED;
            
            this.balls.push({
                x: this.shootPos.x, y: this.shootPos.y,
                vx: normVx, vy: normVy,
                active: true,
                bounces: 0
            });
        }
        this.isShooting = true;
    },
 
    loop() {
        this.update();
        this.draw();
        requestAnimationFrame(() => this.loop());
    },
 
    update() {
        if (this.isChoosing) return;
        if (!this.isShooting) return;
 
        // 更新粒子
        for (let i = this.particles.length - 1; i >= 0; i--) {
            let p = this.particles[i];
            p.x += p.vx; p.y += p.vy; p.life--;
            if (p.life <= 0) this.particles.splice(i, 1);
        }
 
        let activeBallCount = 0;
        for (let i = 0; i < this.balls.length; i++) {
            const ball = this.balls[i];
            if (!ball.active) continue;
            activeBallCount++;
            
            ball.x += ball.vx;
            ball.y += ball.vy;
 
            if (ball.x < CONFIG.BALL_RADIUS) { ball.x = CONFIG.BALL_RADIUS; ball.vx *= -1; }
            if (ball.x > this.width - CONFIG.BALL_RADIUS) { ball.x = this.width - CONFIG.BALL_RADIUS; ball.vx *= -1; }
            if (ball.y < CONFIG.BALL_RADIUS) { ball.y = CONFIG.BALL_RADIUS; ball.vy *= -1; }
            
            this.checkItemCollision(ball);
            if(!ball.active) continue;
            
            this.checkBlockCollision(ball);
            
            if (this.isChoosing) return;
 
            if (ball.y > this.safeLineY + CONFIG.BALL_RADIUS) {
                ball.active = false;
            }
        }
 
        if (activeBallCount === 0 && !this.isChoosing) {
            this.endTurn();
        }
    },
 
    checkBlockCollision(ball) {
        for (let i = 0; i < this.blocks.length; i++) {
            const b = this.blocks[i];
            if (ball.x + CONFIG.BALL_RADIUS > b.x && 
                ball.x - CONFIG.BALL_RADIUS < b.x + b.w &&
                ball.y + CONFIG.BALL_RADIUS > b.y && 
                ball.y - CONFIG.BALL_RADIUS < b.y + b.h) {
                
                b.hp -= this.ballDamage;
                this.score += this.ballDamage;
                
                ball.bounces++;
                if (ball.bounces >= this.maxBounces) {
                    ball.active = false;
                    this.updateUI();
                    return; 
                }
 
                const overlapLeft = (ball.x + CONFIG.BALL_RADIUS) - b.x;
                const overlapRight = (b.x + b.w) - (ball.x - CONFIG.BALL_RADIUS);
                const overlapTop = (ball.y + CONFIG.BALL_RADIUS) - b.y;
                const overlapBottom = (b.y + b.h) - (ball.y - CONFIG.BALL_RADIUS);
                const minOverlapX = Math.min(overlapLeft, overlapRight);
                const minOverlapY = Math.min(overlapTop, overlapBottom);
 
                if (minOverlapX < minOverlapY) {
                    ball.vx *= -1;
                    ball.x += (overlapLeft < overlapRight) ? -minOverlapX : minOverlapX;
                } else {
                    ball.vy *= -1;
                    ball.y += (overlapTop < overlapBottom) ? -minOverlapY : minOverlapY;
                }
 
                if (b.hp <= 0) {
                    if (b.type === CONFIG.ITEM_TYPE.SKILL_FRUIT) {
                        this.triggerSkillSelection();
                    }
                    this.blocks.splice(i, 1);
                    i--;
                }
                
                this.updateUI();
                return; 
            }
        }
    },
 
    checkItemCollision(ball) {
        for (let i = 0; i < this.items.length; i++) {
            const item = this.items[i];
            const dist = Math.sqrt((ball.x - item.x)**2 + (ball.y - item.y)**2);
            
            if (dist < CONFIG.BALL_RADIUS + 15) {
                if (item.type === CONFIG.ITEM_TYPE.BOMB) {
                    ball.active = false;
                    this.explode(item.x, item.y);
                } else if (item.type === CONFIG.ITEM_TYPE.VORTEX) {
                    ball.active = false;
                    for(let k=0; k<10; k++) this.particles.push({x:item.x, y:item.y, vx:Math.random()*4-2, vy:Math.random()*4-2, life:20, color:'#8e44ad'});
                }
                this.items.splice(i, 1);
                i--;
            }
        }
    },
 
    explode(x, y) {
        const radius = 80;
        for(let k=0; k<20; k++) this.particles.push({x, y, vx:Math.random()*8-4, vy:Math.random()*8-4, life:30, color:'#e74c3c'});
        
        for (let i = this.blocks.length - 1; i >= 0; i--) {
            const b = this.blocks[i];
            const bx = b.x + b.w/2;
            const by = b.y + b.h/2;
            const dist = Math.sqrt((x-bx)**2 + (y-by)**2);
            if (dist < radius) {
                b.hp -= this.explosionDamage;
                this.score += this.explosionDamage;
                
                if(b.hp <= 0) {
                    this.blocks.splice(i, 1);
                }
            }
        }
        this.updateUI();
    },
 
    endTurn() {
        this.isShooting = false;
        this.balls = [];
        
        const moveDown = 45 + CONFIG.BLOCK_PADDING;
        for (let b of this.blocks) b.y += moveDown;
        for (let item of this.items) item.y += moveDown;
 
        for (let b of this.blocks) {
            if (b.y + b.h > this.safeLineY) { 
                this.gameOver();
                return;
            }
        }
        
        this.level++;
        this.generateBlocks(false);
        this.updateUI();
    },
 
    triggerSkillSelection() {
        this.isChoosing = true;
        const modal = document.getElementById('roguelikeModal');
        const container = document.getElementById('skillOptions');
        container.innerHTML = '';
        
        const shuffled = [...SKILLS].sort(() => 0.5 - Math.random()).slice(0, 3);
        
        shuffled.forEach(skill => {
            const btn = document.createElement('div');
            btn.className = 'skill-btn';
            btn.innerHTML = `<span class="skill-name">${skill.name}</span><span class="skill-desc">${skill.desc}</span>`;
            btn.onclick = () => {
                skill.effect(this);
                this.updateUI();
                modal.style.display = 'none';
                this.isChoosing = false;
            };
            container.appendChild(btn);
        });
 
        modal.style.display = 'flex';
    },
 
    generateBlocks(isInit) {
        const cols = CONFIG.BLOCK_COLS;
        const totalPadding = (cols + 1) * CONFIG.BLOCK_PADDING;
        const blockW = (this.width - totalPadding) / cols;
        const blockH = 40;
        const y = 10; 
 
        for (let i = 0; i < cols; i++) {
            const x = CONFIG.BLOCK_PADDING + i * (blockW + CONFIG.BLOCK_PADDING);
            
            if (isInit) {
                const hp = Math.floor(Math.random() * (this.level * 2)) + this.level;
                this.blocks.push({ x, y, w: blockW, h: blockH, hp, type: 'normal' });
                continue;
            }
 
            const rand = Math.random();
            
            if (rand < 0.80) { 
                const hp = Math.floor(Math.random() * (this.level * 2)) + this.level;
                this.blocks.push({ x, y, w: blockW, h: blockH, hp, type: 'normal' });
            } 
            else if (rand < 0.8533) {
                const hp = 1; 
                this.blocks.push({ x, y, w: blockW, h: blockH, hp, type: CONFIG.ITEM_TYPE.SKILL_FRUIT });
            }
            else if (rand < 0.9200) {
                this.items.push({ x: x + blockW/2, y: y + blockH/2, type: CONFIG.ITEM_TYPE.BOMB });
            }
            else if (rand < 0.9500) {
                this.items.push({ x: x + blockW/2, y: y + blockH/2, type: CONFIG.ITEM_TYPE.VORTEX });
            }
        }
    },
 
    gameOver() {
        if (this.score > this.bestScore) {
            this.bestScore = this.score;
            localStorage.setItem('bestScore_rogue', this.bestScore);
        }
        document.getElementById('finalScore').innerText = this.score;
        document.getElementById('bestScore').innerText = this.bestScore;
        document.getElementById('gameOverModal').style.display = 'flex';
        document.getElementById('roguelikeModal').style.display = 'none';
    },
 
    loadBestScore() {
        this.bestScore = parseInt(localStorage.getItem('bestScore_rogue')) || 0;
    },
 
    updateUI() {
        document.getElementById('uiScore').innerText = this.score;
        document.getElementById('uiBounces').innerText = this.maxBounces;
        document.getElementById('uiDamage').innerText = this.ballDamage;
        document.getElementById('uiExplosion').innerText = this.explosionDamage;
        document.getElementById('uiCount').innerText = this.ballCount;
    },
 
    // --- 渲染 ---
    draw() {
        ctx.clearRect(0, 0, this.width, this.height);
 
        ctx.fillStyle = '#0f0f1e';
        ctx.fillRect(0, 0, this.width, this.height);
 
        ctx.fillStyle = '#1a1a2e';
        ctx.fillRect(0, this.safeLineY, this.width, this.height - this.safeLineY);
        
        ctx.strokeStyle = 'rgba(255, 0, 0, 0.3)';
        ctx.lineWidth = 2;
        ctx.beginPath(); ctx.moveTo(0, this.safeLineY); ctx.lineTo(this.width, this.safeLineY); ctx.stroke();
 
        ctx.textAlign = 'center'; ctx.textBaseline = 'middle';
        
        // 绘制方块
        for (let b of this.blocks) {
            if (b.type === 'normal') {
                const hue = 200 + (b.hp % 10) * 15;
                ctx.fillStyle = `hsl(${hue}, 60%, 45%)`;
                this.roundRect(b.x, b.y, b.w, b.h, 4, true, false);
                ctx.fillStyle = '#fff';
                ctx.font = 'bold 14px Arial';
                ctx.fillText(b.hp, b.x + b.w/2, b.y + b.h/2);
            } 
            else if (b.type === CONFIG.ITEM_TYPE.SKILL_FRUIT) {
                ctx.fillStyle = `rgba(255, 215, 0, ${0.5 + Math.sin(Date.now() / 200) * 0.5})`;
                this.roundRect(b.x, b.y, b.w, b.h, 4, true, false);
                ctx.strokeStyle = '#fff';
                ctx.lineWidth = 2;
                this.roundRect(b.x, b.y, b.w, b.h, 4, false, true);
                
                ctx.fillStyle = '#000';
                ctx.font = 'bold 12px Arial';
                ctx.fillText('技能', b.x + b.w/2, b.y + b.h/2);
            }
        }
 
        // 绘制道具
        for (let item of this.items) {
            ctx.beginPath();
            ctx.arc(item.x, item.y, 12, 0, Math.PI*2);
            if (item.type === CONFIG.ITEM_TYPE.BOMB) {
                ctx.fillStyle = '#e74c3c'; ctx.fill();
                ctx.fillStyle = '#fff'; ctx.fillText('B', item.x, item.y);
            } else {
                ctx.fillStyle = '#8e44ad'; ctx.fill();
                ctx.fillStyle = '#fff'; ctx.fillText('V', item.x, item.y);
            }
        }
 
        // 绘制粒子
        for(let p of this.particles) {
            ctx.fillStyle = p.color;
            ctx.globalAlpha = p.life / 30;
            ctx.beginPath(); ctx.arc(p.x, p.y, 3, 0, Math.PI*2); ctx.fill();
        }
        ctx.globalAlpha = 1.0;
 
        // 瞄准UI
        if (this.isAiming && !this.isChoosing) {
            ctx.beginPath(); ctx.arc(this.shootPos.x, this.shootPos.y, 10, 0, Math.PI*2);
            ctx.fillStyle = 'rgba(255, 255, 255, 0.8)'; ctx.fill();
            
            let dx = this.shootPos.x - this.aimPos.x;
            let dy = this.shootPos.y - this.aimPos.y;
            if (dy > 0) dy = -1;
 
            ctx.beginPath();
            ctx.moveTo(this.shootPos.x, this.shootPos.y);
            ctx.lineTo(this.shootPos.x + dx * 20, this.shootPos.y + dy * 20);
            ctx.strokeStyle = '#fff'; ctx.lineWidth = 2; ctx.setLineDash([5, 5]); ctx.stroke(); ctx.setLineDash([]);
        } else if (!this.isShooting && !this.isChoosing) {
             ctx.beginPath(); ctx.arc(this.shootPos.x, this.shootPos.y, 8, 0, Math.PI*2);
             ctx.fillStyle = 'rgba(255, 255, 255, 0.5)'; ctx.fill();
             ctx.fillStyle = 'rgba(255, 255, 255, 0.3)'; ctx.font = '12px Arial';
             ctx.fillText('发射', this.shootPos.x, this.shootPos.y + 30);
        }
 
        // 小球
        ctx.fillStyle = '#fff';
        ctx.shadowColor = '#fff'; ctx.shadowBlur = 10;
        for (let ball of this.balls) {
            if (ball.active) {
                ctx.beginPath();
                ctx.arc(ball.x, ball.y, CONFIG.BALL_RADIUS, 0, Math.PI*2);
                ctx.fill();
            }
        }
        ctx.shadowBlur = 0;
    },
 
    roundRect(x, y, w, h, r, fill, stroke) {
        ctx.beginPath();
        ctx.moveTo(x + r, y); ctx.lineTo(x + w - r, y);
        ctx.quadraticCurveTo(x + w, y, x + w, y + r);
        ctx.lineTo(x + w, y + h - r);
        ctx.quadraticCurveTo(x + w, y + h, x + w - r, y + h);
        ctx.lineTo(x + r, y + h);
        ctx.quadraticCurveTo(x, y + h, x, y + h - r);
        ctx.lineTo(x, y + r);
        ctx.quadraticCurveTo(x, y, x + r, y);
        ctx.closePath();
        if (fill) ctx.fill();
        if (stroke) ctx.stroke();
    }
};
 
game.init();


✅ Low Risk - https://secondary-red-rsmcgm6go3-5en62d91q9.edgeone.app/

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

Security Scan Report: secondary-red-rsmcgm6go3-5en62d91q9.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