Rain: Constellation Messenger

entertainment media

news media journalism

documentation technical

English

Domain 'rainconstellation-b9gngvu5y4.edgeone.app' uses the application-focused generic top-level domain (.app) with subdomain 'rainconstellation-b9gngvu5y4'. The second-level label 'edgeone' is 7 characters long with 4 vowels and 3 consonants. It segments into 2 words: edge, one. The median word length lands at 3.5 characters. No strong language cues emerged from the frequency lists.

html/0b/56/0b56b590-19c1-4130-ad48-69e8c2b3a30d.html.gz

4c39429bd905f2c229ae48ecde9bf953111795c7cee7acf3f12277859026b4f7

width=device-width, initial-scale=1.0, viewport-fit=cover

viewport

html/0b/56/0b56b590-19c1-4130-ad48-69e8c2b3a30d_nodriver.html.gz

Prudence Malinki

MarkMonitor Inc.

edgeone.app


        // ========== POETIC MESSAGES DATABASE ==========
        const messagePool = [
            "You didn't stop it… you just made space.",
            "Some moments exist only when you notice them.",
            "It's been one month since Rain touched my days.",
            "Every drop waits for your hand.",
            "The rain only exists when you choose it.",
            "You control what falls… and what remains.",
            "Some storms feel like home.",
            "Silence speaks louder than words.",
            "One month of moments in liquid form.",
            "You found the constellation within.",
            "Drops are dreams that learned to fall.",
            "In every raindrop, a thousand stories.",
        ];

        const constellationMessages = [
            "It's been one month since Rain touched my days.",
            "Some things exist because you notice them.",
            "You drew constellations from the falling sky.",
            "This isn't a question. Just a moment.",
            "Every drop was waiting for this connection.",
        ];

        const finalMessages = [
            "Some things exist because you notice them.",
            "Thank you for becoming the rain.",
            "This moment is yours forever.",
        ];

        // ========== CANVAS SETUP ==========
        const canvas = document.getElementById('rainCanvas');
        const ctx = canvas.getContext('2d');

        function resizeCanvas() {
            canvas.width = window.innerWidth;
            canvas.height = window.innerHeight;
        }
        resizeCanvas();
        window.addEventListener('resize', resizeCanvas);

        // ========== STATE MANAGEMENT ==========
        const state = {
            raindrops: [],
            tappedDroplets: [],
            constellationLines: [],
            isPaused: false,
            rainIntensity: 'drizzle', // drizzle, storm, pause
            deviceTilt: { beta: 0, gamma: 0 },
            showingMessage: false,
            messageTimeout: null,
            constellationFormed: false,
            isReplaying: false,
            phase: 'landing', // landing, active, constellation, finale
        };

        // ========== RAINDROP CLASS ==========
        class Raindrop {
            constructor(x, y) {
                this.x = x;
                this.y = y;
                this.vx = (Math.random() - 0.5) * 2 + (state.deviceTilt.gamma / 30);
                this.vy = Math.random() * 4 + 3;
                this.length = Math.random() * 8 + 10;
                this.width = Math.random() * 1.5 + 0.5;
                this.opacity = Math.random() * 0.4 + 0.5;
                this.isTapped = false;
                this.tapTime = null;
                this.glowIntensity = 0;
            }

            update() {
                if (!state.isPaused) {
                    this.x += this.vx;
                    this.y += this.vy;

                    // Wrap around screen
                    if (this.x > canvas.width + 20) this.x = -20;
                    if (this.x < -20) this.x = canvas.width + 20;
                    if (this.y > canvas.height + 20) {
                        this.reset();
                    }
                }

                // Manage glow effect when tapped
                if (this.isTapped && this.tapTime) {
                    const elapsed = Date.now() - this.tapTime;
                    this.glowIntensity = Math.max(0, 1 - elapsed / 600);
                    if (this.glowIntensity === 0) {
                        this.isTapped = false;
                    }
                }
            }

            reset() {
                this.x = Math.random() * canvas.width;
                this.y = -20;
                this.vx = (Math.random() - 0.5) * 2 + (state.deviceTilt.gamma / 30);
                this.vy = Math.random() * 4 + 3;
                this.isTapped = false;
                this.glowIntensity = 0;
            }

            draw() {
                ctx.strokeStyle = `rgba(200, 230, 255, ${this.opacity + this.glowIntensity * 0.3})`;
                ctx.lineWidth = this.width + this.glowIntensity * 1.5;
                ctx.lineCap = 'round';
                ctx.lineJoin = 'round';

                ctx.beginPath();
                ctx.moveTo(this.x, this.y);
                ctx.lineTo(this.x + this.vx * 0.5, this.y + this.length);
                ctx.stroke();

                // Glow effect when tapped
                if (this.glowIntensity > 0) {
                    ctx.shadowColor = `rgba(56, 189, 248, ${this.glowIntensity * 0.8})`;
                    ctx.shadowBlur = 20;
                    ctx.strokeStyle = `rgba(56, 189, 248, ${this.glowIntensity * 0.5})`;
                    ctx.lineWidth = this.width * 3;
                    ctx.beginPath();
                    ctx.moveTo(this.x, this.y);
                    ctx.lineTo(this.x + this.vx * 0.5, this.y + this.length);
                    ctx.stroke();
                    ctx.shadowColor = 'transparent';
                }
            }

            distanceTo(x, y) {
                const dx = this.x - x;
                const dy = this.y - y;
                return Math.sqrt(dx * dx + dy * dy);
            }
        }

        // ========== INITIALIZATION ==========
        function initializeRain() {
            state.raindrops = [];
            for (let i = 0; i < 50; i++) {
                const drop = new Raindrop(
                    Math.random() * canvas.width,
                    Math.random() * canvas.height
                );
                state.raindrops.push(drop);
            }
        }

        // ========== INTENSITY MANAGEMENT ==========
        function setRainIntensity(intensity) {
            state.rainIntensity = intensity;

            if (intensity === 'drizzle') {
                state.raindrops.forEach(drop => {
                    drop.vy = Math.random() * 2 + 1.5;
                    drop.opacity = Math.random() * 0.3 + 0.3;
                });
                showMessage("The rain slows to a whisper.");
            } else if (intensity === 'storm') {
                state.raindrops.forEach(drop => {
                    drop.vy = Math.random() * 6 + 5;
                    drop.opacity = Math.random() * 0.5 + 0.6;
                });
                showMessage("The storm descends.");
            } else if (intensity === 'pause') {
                state.isPaused = !state.isPaused;
                showMessage(state.isPaused ? "Rain holds its breath." : "Rain resumes.");
            }
        }

        // ========== MESSAGE DISPLAY ==========
        function showMessage(message, duration = 2500) {
            const container = document.getElementById('messageContainer');
            const display = document.createElement('div');
            display.className = 'message-display glowing-text';
            display.textContent = message;
            
            container.innerHTML = '';
            container.appendChild(display);

            if (state.messageTimeout) clearTimeout(state.messageTimeout);

            state.messageTimeout = setTimeout(() => {
                display.remove();
            }, duration);
        }

        // ========== RAINDROP TAPPING ==========
        function handleCanvasTap(e) {
            if (state.phase === 'landing') {
                state.phase = 'active';
                showMessage("Tap a raindrop to discover a message.", 3000);
                return;
            }

            const rect = canvas.getBoundingClientRect();
            const x = e.touches ? e.touches[0].clientX - rect.left : e.clientX - rect.left;
            const y = e.touches ? e.touches[0].clientY - rect.top : e.clientY - rect.top;

            let tappedDrop = null;
            for (let drop of state.raindrops) {
                if (drop.distanceTo(x, y) < 20) {
                    tappedDrop = drop;
                    break;
                }
            }

            if (tappedDrop && !tappedDrop.isTapped) {
                tappedDrop.isTapped = true;
                tappedDrop.tapTime = Date.now();

                const message = messagePool[Math.floor(Math.random() * messagePool.length)];
                showMessage(message, 2500);

                // Record tapped droplet
                state.tappedDroplets.push({
                    x: tappedDrop.x,
                    y: tappedDrop.y,
                });

                // Check for constellation trigger
                if (state.tappedDroplets.length >= 3 && !state.constellationFormed && Math.random() < 0.4) {
                    formConstellation();
                }
            }
        }

        // ========== CONSTELLATION FORMATION ==========
        function formConstellation() {
            state.constellationFormed = true;
            state.phase = 'constellation';

            // Create lines between tapped droplets
            for (let i = 0; i < state.tappedDroplets.length - 1; i++) {
                state.constellationLines.push({
                    x1: state.tappedDroplets[i].x,
                    y1: state.tappedDroplets[i].y,
                    x2: state.tappedDroplets[i + 1].x,
                    y2: state.tappedDroplets[i + 1].y,
                    opacity: 0,
                    maxOpacity: Math.random() * 0.4 + 0.3,
                });
            }

            // Show constellation message
            setTimeout(() => {
                const conMsg = constellationMessages[Math.floor(Math.random() * constellationMessages.length)];
                showMessage(conMsg, 3500);
            }, 800);
        }

        // ========== REVEAL HIDDEN MESSAGE ==========
        function revealThought() {
            const messages = [
                "The rain only exists when you choose it.",
                "You control what falls… and what remains.",
                "Some storms feel like home.",
                "Every moment is a constellation waiting to be drawn.",
                "This is exactly where you need to be.",
            ];
            const message = messages[Math.floor(Math.random() * messages.length)];
            showMessage(message, 3000);
        }

        // ========== FINALE SEQUENCE ==========
        function triggerFinale() {
            state.phase = 'finale';
            state.isPaused = true;

            // Slow gradient transition
            const finalMsg = finalMessages[Math.floor(Math.random() * finalMessages.length)];
            showMessage(finalMsg, 4000);

            // Show replay button
            setTimeout(() => {
                document.getElementById('replayBtn').style.display = 'block';
            }, 2500);
        }

        // ========== REPLAY FUNCTIONALITY ==========
        function replay() {
            state.tappedDroplets = [];
            state.constellationLines = [];
            state.constellationFormed = false;
            state.isPaused = false;
            state.rainIntensity = 'drizzle';
            state.phase = 'active';
            state.isReplaying = true;

            document.getElementById('replayBtn').style.display = 'none';
            initializeRain();

            showMessage("Begin again. The rain awaits.", 2500);
        }

        // ========== DEVICE ORIENTATION (OPTIONAL TILT) ==========
        function handleDeviceOrientation(event) {
            state.deviceTilt.beta = event.beta || 0;
            state.deviceTilt.gamma = event.gamma || 0;

            // Adjust rain angle based on tilt
            state.raindrops.forEach(drop => {
                drop.vx = (Math.random() - 0.5) * 2 + (state.deviceTilt.gamma / 40);
            });
        }

        if ('DeviceOrientationEvent' in window) {
            window.addEventListener('deviceorientation', handleDeviceOrientation);
        }

        // ========== EVENT LISTENERS ==========
        canvas.addEventListener('touchstart', handleCanvasTap);
        canvas.addEventListener('click', handleCanvasTap);

        document.getElementById('drizzleBtn').addEventListener('click', () => setRainIntensity('drizzle'));
        document.getElementById('stormBtn').addEventListener('click', () => setRainIntensity('storm'));
        document.getElementById('pauseBtn').addEventListener('click', () => setRainIntensity('pause'));
        document.getElementById('revealBtn').addEventListener('click', revealThought);
        document.getElementById('replayBtn').addEventListener('click', replay);

        // ========== DRAWING & ANIMATION LOOP ==========
        function drawConstellationLines() {
            state.constellationLines.forEach(line => {
                // Fade in constellation lines
                if (line.opacity < line.maxOpacity) {
                    line.opacity += 0.03;
                }

                ctx.strokeStyle = `rgba(56, 189, 248, ${line.opacity})`;
                ctx.lineWidth = 1.5;
                ctx.lineCap = 'round';

                ctx.beginPath();
                ctx.moveTo(line.x1, line.y1);
                ctx.lineTo(line.x2, line.y2);
                ctx.stroke();

                // Glow on lines
                ctx.shadowColor = `rgba(56, 189, 248, ${line.opacity * 0.6})`;
                ctx.shadowBlur = 8;
                ctx.strokeStyle = `rgba(100, 200, 255, ${line.opacity * 0.4})`;
                ctx.lineWidth = 2;
                ctx.beginPath();
                ctx.moveTo(line.x1, line.y1);
                ctx.lineTo(line.x2, line.y2);
                ctx.stroke();
                ctx.shadowColor = 'transparent';
            });
        }

        function drawParticles() {
            // Optional shimmer particles during finale
            if (state.phase === 'finale') {
                for (let i = 0; i < 3; i++) {
                    const x = Math.random() * canvas.width;
                    const y = canvas.height * 0.6 + Math.random() * 100;
                    const size = Math.random() * 2 + 1;
                    const opacity = Math.random() * 0.3;

                    ctx.fillStyle = `rgba(200, 230, 255, ${opacity})`;
                    ctx.beginPath();
                    ctx.arc(x, y, size, 0, Math.PI * 2);
                    ctx.fill();
                }
            }
        }

        function animate() {
            // Clear canvas with gradient
            const gradient = ctx.createLinearGradient(0, 0, 0, canvas.height);
            gradient.addColorStop(0, 'rgba(10, 20, 40, 0.95)');
            gradient.addColorStop(0.5, 'rgba(26, 42, 74, 0.95)');
            
            if (state.phase === 'finale') {
                gradient.addColorStop(1, 'rgba(50, 50, 30, 0.95)');
            } else {
                gradient.addColorStop(1, 'rgba(42, 58, 90, 0.95)');
            }

            ctx.fillStyle = gradient;
            ctx.fillRect(0, 0, canvas.width, canvas.height);

            // Update and draw raindrops
            state.raindrops.forEach(drop => {
                drop.update();
                drop.draw();
            });

            // Draw constellation
            if (state.constellationLines.length > 0) {
                drawConstellationLines();
            }

            // Draw particles
            drawParticles();

            requestAnimationFrame(animate);
        }

        // ========== STARTUP SEQUENCE ==========
        function startup() {
            initializeRain();

            // Show landing message
            showMessage("Some things don't start loudly.", 3500);

            // Show instruction after landing message
            setTimeout(() => {
                showMessage("Tap a raindrop to discover a message.", 4000);
            }, 3800);

            // Auto-trigger finale after extended interaction (optional)
            setTimeout(() => {
                if (state.phase === 'active' && !state.isReplaying) {
                    triggerFinale();
                }
            }, 45000);

            animate();
        }

        startup();
    

✅ Low Risk - https://rainconstellation-b9gngvu5y4.edgeone.app/

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

Security Scan Report: rainconstellation-b9gngvu5y4.edgeone.app

Summary

AI Security Verdict

Safe Website

Safety Factors

Details

Bot Protection Detected

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