Skip to content
TheChatArchiveThe Chat Archive
Geminigemini-2.5-pro-preview-05-06· GoogleHugging Face LMArena Human Preference 140K

Хочу создать html страницу в киберпанк тематике. Размышляю о том, как могут выглядеть…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Claudeclaude-sonnet-4-20250514’s answer.
  1. User

    Хочу создать html страницу в киберпанк тематике. Размышляю о том, как могут выглядеть часы на такой странице. Помоги пожалуйста. Предложи несколько вариантов в виде html документаПредложи варианты, сходные с реальными часами, например с сегментными индикаторами. Придумай еще интересные варианты

  2. Gemini Assistant

    Отличная идея! Киберпанк-часы могут быть очень стильными. Вот несколько вариантов в виде HTML-документов. Каждый из них – это полноценная страница, которую можно сохранить как .html файл и открыть в браузере.

    Я постарался сделать их разными: от классических сегментных до более футуристичных.

    Общие моменты для всех вариантов:

    • Используется шрифт 'Orbitron' с Google Fonts, он хорошо подходит по стилистике.
    • Базовая цветовая схема: темный фон, яркие неоновые цвета для текста.
    • JavaScript для обновления времени.

    Вариант 1: Классические сегментные индикаторы (упрощенные)

    Этот вариант имитирует семисегментные индикаторы, но для простоты я сделал их немного стилизованными.

    <!DOCTYPE html>
    <html lang="ru">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Cyberpunk Segment Clock</title>
        <link href="https://fonts.googleapis.com/css2?family=Orbitron:wght@400;700&display=swap" rel="stylesheet">
        <style>
            body {
                background-color: #0a0a1f; /* Темно-синий/фиолетовый фон */
                color: #0ff; /* Яркий циан */
                font-family: 'Orbitron', sans-serif;
                display: flex;
                justify-content: center;
                align-items: center;
                min-height: 100vh;
                margin: 0;
                overflow: hidden;
            }
    
            .clock-container {
                display: flex;
                align-items: flex-end; /* Чтобы двоеточия были ниже */
                text-shadow: 0 0 5px #0ff, 0 0 10px #0ff, 0 0 15px #0ff, 0 0 20px #0ff;
            }
    
            .digit-group {
                display: flex;
            }
    
            .digit {
                width: 60px; /* Ширина одного "сегмента" */
                height: 100px; /* Высота "сегмента" */
                margin: 0 5px;
                display: grid;
                grid-template-columns: repeat(3, 1fr);
                grid-template-rows: repeat(5, 1fr);
                gap: 3px;
            }
    
            .segment {
                background-color: rgba(0, 255, 255, 0.15); /* Полупрозрачный фон для неактивных сегментов */
                transition: background-color 0.3s ease;
            }
    
            .segment.on {
                background-color: #0ff;
                box-shadow: 0 0 3px #0ff, 0 0 5px #0ff;
            }
    
            /* Определения для каждого сегмента (A-G) по их позиции в сетке */
            /* Верхний (A) */
            .sA { grid-column: 1 / span 3; grid-row: 1; }
            /* Верхний левый (F) */
            .sF { grid-column: 1; grid-row: 2; }
            /* Верхний правый (B) */
            .sB { grid-column: 3; grid-row: 2; }
            /* Средний (G) */
            .sG { grid-column: 1 / span 3; grid-row: 3; }
            /* Нижний левый (E) */
            .sE { grid-column: 1; grid-row: 4; }
            /* Нижний правый (C) */
            .sC { grid-column: 3; grid-row: 4; }
            /* Нижний (D) */
            .sD { grid-column: 1 / span 3; grid-row: 5; }
    
    
            .separator {
                font-size: 60px;
                line-height: 90px; /* Чтобы было примерно по центру цифр */
                padding: 0 10px;
                animation: blink 1s infinite;
            }
    
            @keyframes blink {
                0%, 100% { opacity: 1; }
                50% { opacity: 0.3; }
            }
        </style>
    </head>
    <body>
        <div class="clock-container">
            <div class="digit-group" id="hours">
                <div class="digit" id="h1"></div>
                <div class="digit" id="h2"></div>
            </div>
            <div class="separator">:</div>
            <div class="digit-group" id="minutes">
                <div class="digit" id="m1"></div>
                <div class="digit" id="m2"></div>
            </div>
            <div class="separator">:</div>
            <div class="digit-group" id="seconds">
                <div class="digit" id="s1"></div>
                <div class="digit" id="s2"></div>
            </div>
        </div>
    
        <script>
            const segmentMap = [
                ['sA', 'sB', 'sC', 'sD', 'sE', 'sF'],    // 0
                ['sB', 'sC'],                            // 1
                ['sA', 'sB', 'sG', 'sE', 'sD'],          // 2
                ['sA', 'sB', 'sG', 'sC', 'sD'],          // 3
                ['sF', 'sG', 'sB', 'sC'],                // 4
                ['sA', 'sF', 'sG', 'sC', 'sD'],          // 5
                ['sA', 'sF', 'sG', 'sE', 'sC', 'sD'],    // 6
                ['sA', 'sB', 'sC'],                      // 7
                ['sA', 'sB', 'sC', 'sD', 'sE', 'sF', 'sG'],// 8
                ['sA', 'sB', 'sC', 'sD', 'sF', 'sG']     // 9
            ];
    
            function createDigitElement(id) {
                const digitContainer = document.getElementById(id);
                if (!digitContainer) {
                    console.error("Digit container not found:", id);
                    return;
                }
                digitContainer.innerHTML = ''; // Clear previous segments
                ['sA', 'sF', 'sB', 'sG', 'sE', 'sC', 'sD'].forEach(sClass => {
                    const segmentDiv = document.createElement('div');
                    segmentDiv.classList.add('segment', sClass);
                    digitContainer.appendChild(segmentDiv);
                });
            }
    
            function displayDigit(digitId, number) {
                const digitContainer = document.getElementById(digitId);
                if (!digitContainer) return;
    
                const segmentsToTurnOn = segmentMap[number];
                const allSegments = digitContainer.querySelectorAll('.segment');
    
                allSegments.forEach(seg => {
                    seg.classList.remove('on');
                });
    
                if (segmentsToTurnOn) {
                    segmentsToTurnOn.forEach(segClass => {
                        const segmentElement = digitContainer.querySelector('.' + segClass);
                        if (segmentElement) {
                            segmentElement.classList.add('on');
                        }
                    });
                }
            }
    
            function initDigits() {
                ['h1', 'h2', 'm1', 'm2', 's1', 's2'].forEach(id => createDigitElement(id));
            }
    
            function updateClock() {
                const now = new Date();
                const h = now.getHours();
                const m = now.getMinutes();
                const s = now.getSeconds();
    
                displayDigit('h1', Math.floor(h / 10));
                displayDigit('h2', h % 10);
                displayDigit('m1', Math.floor(m / 10));
                displayDigit('m2', m % 10);
                displayDigit('s1', Math.floor(s / 10));
                displayDigit('s2', s % 10);
            }
    
            initDigits();
            setInterval(updateClock, 1000);
            updateClock(); // Initial call
        </script>
    </body>
    </html>
    

    Вариант 2: "Глитч" часы

    Этот вариант использует CSS-анимации для создания эффекта глитча на цифрах.

    <!DOCTYPE html>
    <html lang="ru">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Cyberpunk Glitch Clock</title>
        <link href="https://fonts.googleapis.com/css2?family=Orbitron:wght@700&family=VT323&display=swap" rel="stylesheet">
        <style>
            body {
                background-color: #08000f; /* Очень темный фиолетовый */
                color: #ff00ff; /* Яркая маджента */
                font-family: 'VT323', monospace; /* Пиксельный шрифт */
                display: flex;
                justify-content: center;
                align-items: center;
                min-height: 100vh;
                margin: 0;
                overflow: hidden; /* Чтобы глитч не вылезал за экран */
            }
    
            .clock-container {
                font-size: 10vw; /* Размер зависит от ширины экрана */
                font-weight: 700;
                position: relative;
                text-shadow: 0 0 5px #ff00ff, 0 0 10px #ff00ff;
            }
    
            .glitch-clock {
                position: relative;
            }
    
            .glitch-clock::before,
            .glitch-clock::after {
                content: attr(data-text);
                position: absolute;
                top: 0;
                left: 0;
                width: 100%;
                height: 100%;
                background: #08000f; /* Фон такой же как у body */
                overflow: hidden;
            }
    
            .glitch-clock::before {
                left: 2px;
                text-shadow: -1px 0 #00ffff; /* Циановый сдвиг */
                animation: glitch-anim-1 2.5s infinite linear alternate-reverse;
            }
    
            .glitch-clock::after {
                left: -2px;
                text-shadow: -1px 0 #00ff00, 1px 1px #ff00ff; /* Зеленый + маджента сдвиг */
                animation: glitch-anim-2 2s infinite linear alternate-reverse;
            }
            
            @keyframes glitch-anim-1 {
                0% { clip-path: inset(10% 0 80% 0); }
                10% { clip-path: inset(40% 0 30% 0); }
                20% { clip-path: inset(90% 0 2% 0); }
                30% { clip-path: inset(25% 0 50% 0); }
                40% { clip-path: inset(5% 0 70% 0); }
                50% { clip-path: inset(60% 0 15% 0); }
                60% { clip-path: inset(80% 0 5% 0); }
                70% { clip-path: inset(15% 0 65% 0); }
                80% { clip-path: inset(50% 0 20% 0); }
                90% { clip-path: inset(75% 0 10% 0); }
                100% { clip-path: inset(20% 0 75% 0); }
            }
    
            @keyframes glitch-anim-2 {
                0% { clip-path: inset(85% 0 5% 0); transform: translateX(-3px); }
                10% { clip-path: inset(10% 0 60% 0); transform: translateX(1px); }
                20% { clip-path: inset(70% 0 10% 0); transform: translateX(3px); }
                30% { clip-path: inset(35% 0 40% 0); transform: translateX(-2px); }
                40% { clip-path: inset(20% 0 75% 0); transform: translateX(2px); }
                50% { clip-path: inset(55% 0 5% 0); transform: translateX(-3px); }
                60% { clip-path: inset(5% 0 90% 0); transform: translateX(3px); }
                70% { clip-path: inset(65% 0 20% 0); transform: translateX(-1px); }
                80% { clip-path: inset(30% 0 55% 0); transform: translateX(1px); }
                90% { clip-path: inset(80% 0 15% 0); transform: translateX(-2px); }
                100% { clip-path: inset(45% 0 30% 0); transform: translateX(2px); }
            }
        </style>
    </head>
    <body>
        <div class="clock-container">
            <div class="glitch-clock" id="glitchClock" data-text="00:00:00">00:00:00</div>
        </div>
    
        <script>
            const clockElement = document.getElementById('glitchClock');
    
            function updateClock() {
                const now = new Date();
                const h = String(now.getHours()).padStart(2, '0');
                const m = String(now.getMinutes()).padStart(2, '0');
                const s = String(now.getSeconds()).padStart(2, '0');
                
                const timeString = `${h}:${m}:${s}`;
                clockElement.textContent = timeString;
                clockElement.setAttribute('data-text', timeString); // Важно для псевдоэлементов
            }
    
            setInterval(updateClock, 1000);
            updateClock(); // Initial call
        </script>
    </body>
    </html>
    

    Вариант 3: HUD-стиль / Сканер

    Этот вариант имитирует интерфейс на лобовом стекле или сканере, с линиями и минималистичным отображением.

    <!DOCTYPE html>
    <html lang="ru">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Cyberpunk HUD Clock</title>
        <link href="https://fonts.googleapis.com/css2?family=Orbitron:wght@500&display=swap" rel="stylesheet">
        <style>
            body {
                background-color: #000;
                color: #0f0; /* Классический зеленый терминал */
                font-family: 'Orbitron', sans-serif;
                display: flex;
                justify-content: center;
                align-items: center;
                min-height: 100vh;
                margin: 0;
                overflow: hidden;
                position: relative; /* Для scanline */
            }
    
            .clock-container {
                border: 2px solid rgba(0, 255, 0, 0.5);
                padding: 30px 40px;
                box-shadow: 0 0 15px rgba(0, 255, 0, 0.5), inset 0 0 15px rgba(0, 255, 0, 0.3);
                background-color: rgba(0, 20, 0, 0.3); /* Слегка прозрачный фон */
                position: relative;
                z-index: 1;
            }
    
            .time-display {
                font-size: 5vw;
                letter-spacing: 3px;
                text-shadow: 0 0 5px #0f0, 0 0 10px #0f0;
            }
    
            .time-display span {
                display: inline-block;
                min-width: 2.5em; /* Для выравнивания цифр */
                text-align: center;
            }
            
            .time-display .separator {
                min-width: 0.5em;
                animation: blink-hud 1.5s infinite;
            }
    
            /* Эффект сканирующей линии */
            body::after {
                content: '';
                position: absolute;
                top: 0;
                left: 0;
                width: 100%;
                height: 3px;
                background: linear-gradient(90deg, transparent, rgba(0,255,0,0.8), transparent);
                animation: scanline 6s linear infinite;
                z-index: 0;
            }
    
            @keyframes scanline {
                0% { transform: translateY(-10px); opacity: 0; }
                10% { opacity: 1; }
                90% { opacity: 1; }
                100% { transform: translateY(100vh); opacity: 0; }
            }
            
            @keyframes blink-hud {
                0%, 100% { opacity: 1; }
                50% { opacity: 0.4; }
            }
    
            /* Декоративные углы */
            .clock-container::before, .clock-container::after {
                content: '';
                position: absolute;
                width: 20px;
                height: 20px;
                border-color: #0f0;
                border-style: solid;
            }
            .clock-container::before {
                top: -5px; left: -5px;
                border-width: 2px 0 0 2px;
            }
            .clock-container::after {
                bottom: -5px; right: -5px;
                border-width: 0 2px 2px 0;
            }
    
        </style>
    </head>
    <body>
        <div class="clock-container">
            <div class="time-display">
                <span id="hudHours">00</span><span class="separator">:</span><span id="hudMinutes">00</span><span class="separator">:</span><span id="hudSeconds">00</span>
            </div>
        </div>
    
        <script>
            const hoursEl = document.getElementById('hudHours');
            const minutesEl = document.getElementById('hudMinutes');
            const secondsEl = document.getElementById('hudSeconds');
    
            function updateClock() {
                const now = new Date();
                hoursEl.textContent = String(now.getHours()).padStart(2, '0');
                minutesEl.textContent = String(now.getMinutes()).padStart(2, '0');
                secondsEl.textContent = String(now.getSeconds()).padStart(2, '0');
            }
    
            setInterval(updateClock, 1000);
            updateClock(); // Initial call
        </script>
    </body>
    </html>
    

    Вариант 4: Радиальные индикаторы (круговые)

    Этот вариант использует SVG для создания круговых прогресс-баров для часов, минут и секунд, с цифровым дублированием в центре.

    <!DOCTYPE html>
    <html lang="ru">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Cyberpunk Radial Clock</title>
        <link href="https://fonts.googleapis.com/css2?family=Orbitron:wght@400;700&display=swap" rel="stylesheet">
        <style>
            body {
                background-color: #101028;
                color: #7DF9FF; /* Electric Blue */
                font-family: 'Orbitron', sans-serif;
                display: flex;
                justify-content: center;
                align-items: center;
                min-height: 100vh;
                margin: 0;
                overflow: hidden;
            }
    
            .clock-container {
                position: relative;
                width: 300px;
                height: 300px;
            }
    
            .radial-clock svg {
                width: 100%;
                height: 100%;
                transform: rotate(-90deg); /* Начало круга сверху */
            }
    
            .radial-clock circle {
                fill: transparent;
                stroke-width: 12;
            }
    
            .radial-clock .track {
                stroke: rgba(125, 249, 255, 0.2);
            }
    
            .radial-clock .progress {
                stroke: #7DF9FF;
                stroke-linecap: round; /* Закругленные концы прогресса */
                transition: stroke-dashoffset 0.2s linear; /* Плавность для секунд */
                filter: drop-shadow(0 0 3px #7DF9FF);
            }
            
            #hours-progress { stroke: #FF00FF; filter: drop-shadow(0 0 3px #FF00FF); } /* Magenta for hours */
            #minutes-progress { stroke: #00FF00; filter: drop-shadow(0 0 3px #00FF00); } /* Green for minutes */
    
    
            .digital-display {
                position: absolute;
                top: 50%;
                left: 50%;
                transform: translate(-50%, -50%);
                font-size: 36px;
                font-weight: 700;
                text-shadow: 0 0 5px #7DF9FF, 0 0 10px #7DF9FF;
            }
            
            .digital-display .separator {
                animation: blink-radial 1s infinite;
            }
    
            @keyframes blink-radial {
                 0%, 100% { opacity: 1; }
                 50% { opacity: 0.3; }
            }
        </style>
    </head>
    <body>
        <div class="clock-container">
            <div class="radial-clock">
                <svg viewBox="0 0 200 200">
                    <!-- Track and progress for Hours -->
                    <circle class="track" cx="100" cy="100" r="90" />
                    <circle class="progress" id="hours-progress" cx="100" cy="100" r="90" />
                    <!-- Track and progress for Minutes -->
                    <circle class="track" cx="100" cy="100" r="70" />
                    <circle class="progress" id="minutes-progress" cx="100" cy="100" r="70" />
                    <!-- Track and progress for Seconds -->
                    <circle class="track" cx="100" cy="100" r="50" />
                    <circle class="progress" id="seconds-progress" cx="100" cy="100" r="50" />
                </svg>
            </div>
            <div class="digital-display" id="digitalTime">
                <span id="digital-h">00</span><span class="separator">:</span><span id="digital-m">00</span><span class="separator">:</span><span id="digital-s">00</span>
            </div>
        </div>
    
        <script>
            const hoursCircle = document.getElementById('hours-progress');
            const minutesCircle = document.getElementById('minutes-progress');
            const secondsCircle = document.getElementById('seconds-progress');
    
            const digitalH = document.getElementById('digital-h');
            const digitalM = document.getElementById('digital-m');
            const digitalS = document.getElementById('digital-s');
    
            const radiusH = hoursCircle.r.baseVal.value;
            const circumferenceH = 2 * Math.PI * radiusH;
            hoursCircle.style.strokeDasharray = `${circumferenceH} ${circumferenceH}`;
    
            const radiusM = minutesCircle.r.baseVal.value;
            const circumferenceM = 2 * Math.PI * radiusM;
            minutesCircle.style.strokeDasharray = `${circumferenceM} ${circumferenceM}`;
            
            const radiusS = secondsCircle.r.baseVal.value;
            const circumferenceS = 2 * Math.PI * radiusS;
            secondsCircle.style.strokeDasharray = `${circumferenceS} ${circumferenceS}`;
    
    
            function setProgress(circle, circumference, value, max_value) {
                const offset = circumference - (value / max_value) * circumference;
                circle.style.strokeDashoffset = offset;
            }
    
            function updateClock() {
                const now = new Date();
                const h = now.getHours();
                const m = now.getMinutes();
                const s = now.getSeconds();
                const ms = now.getMilliseconds(); // для более плавных секунд
    
                // Для круговых индикаторов
                setProgress(hoursCircle, circumferenceH, h % 12 || 12, 12); // 12-часовой формат для круга
                setProgress(minutesCircle, circumferenceM, m, 60);
                // Плавный переход для секундной стрелки
                const s_with_ms = s + (ms / 1000);
                setProgress(secondsCircle, circumferenceS, s_with_ms, 60);
    
    
                // Для цифрового дисплея
                digitalH.textContent = String(h).padStart(2, '0');
                digitalM.textContent = String(m).padStart(2, '0');
                digitalS.textContent = String(s).padStart(2, '0');
                
                requestAnimationFrame(updateClock); // Используем requestAnimationFrame для плавности секундной стрелки
            }
            
            // Инициализация dashoffset, чтобы при первой загрузке не было полного круга
            hoursCircle.style.strokeDashoffset = circumferenceH;
            minutesCircle.style.strokeDashoffset = circumferenceM;
            secondsCircle.style.strokeDashoffset = circumferenceS;
    
            requestAnimationFrame(updateClock); // Запуск обновления
        </script>
    </body>
    </html>
    
    

    Как использовать:

    1. Скопируйте код одного из вариантов.
    2. Вставьте его в текстовый редактор (например, Блокнот, VS Code, Sublime Text).
    3. Сохраните файл с расширением .html (например, cyberpunk_clock.html).
    4. Откройте этот файл в любом современном веб-браузере.

    Надеюсь, эти варианты дадут хорошее начало для твоей киберпанк-страницы! Ты можешь их дорабатывать, менять цвета, шрифты, анимации и добавлять другие элементы киберпанк-эстетики (например, фоновые сетки, эффекты помех и т.д.).

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.