【修改版】康德计数器网页版 v2.5
说明：修改版本非完全原创
本页面内容修改自由 zysftd所创作的"康德计数器网页版 v2.5":https://scp-wiki-cn.wikidot.com/kangdeweb

修改版有以下特点：
移除了暴毙结局。
无论测量出什么休谟指数都会触发“红现实”事件。
即使找到现实稳定锚仍然可以继续点击格子。(死亡则不能)
大幅度减少等待时间。
大幅度增加休谟指数波动幅度。
大幅度增加现实扭曲节点生成概率。
减少好事件概率。
每测量5次必有一次是100(95%)或者1~10(5%)。
- 隐藏
[[html]]
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>康德计数器 | SCP 基金会 - 休谟指数测量设备</title>
    <style>
        body {
            background-color: #000;
            color: #00cc00;
            font-family: 'Courier New', monospace;
            margin: 0;
            padding: 20px;
            text-align: center;
            line-height: 1.6;
            overflow-x: hidden;
        }

        .container {
            max-width: 800px;
            margin: 0 auto;
            border: 1px solid #00cc00;
            padding: 20px;
            background-color: #0a0a0a;
            box-shadow: 0 0 20px rgba(0, 204, 0, 0.3);
        }

        h1 {
            color: #00ff00;
            text-shadow: 0 0 10px rgba(0, 255, 0, 0.5);
            margin-bottom: 10px;
            font-size: 2.2em;
        }

        .subtitle {
            color: #aaa;
            font-size: 1.1em;
            margin-bottom: 30px;
            font-style: italic;
        }

        .display-container {
            background-color: #000;
            border: 2px solid #00cc00;
            padding: 25px;
            margin: 25px 0;
            border-radius: 5px;
            min-height: 180px;
            display: flex;
            flex-direction: column;
            justify-content: center;
            align-items: center;
        }

        .display {
            font-size: 4.5em;
            font-weight: bold;
            margin: 10px 0;
            text-shadow: 0 0 15px rgba(0, 204, 0, 0.7);
            transition: all 0.3s ease;
        }

        .status {
            font-size: 1.4em;
            margin-top: 10px;
            height: 30px;
        }

        .btn {
            background-color: #002200;
            color: #00cc00;
            border: 1px solid #00cc00;
            padding: 12px 30px;
            font-family: 'Courier New', monospace;
            font-size: 1.2em;
            cursor: pointer;
            margin: 15px 0;
            transition: all 0.2s;
            text-transform: uppercase;
            letter-spacing: 1px;
        }

        .btn:hover {
            background-color: #003300;
            box-shadow: 0 0 10px rgba(0, 204, 0, 0.5);
        }

        .btn:active {
            transform: scale(0.98);
        }

        .normal { color: #00cc00; }
        .low { color: #ff3333; animation: pulse 1.5s infinite; }
        .high { color: #ffff33; }
        .extreme { color: #ff0000; animation: pulse 2s infinite; }

        @keyframes pulse {
            0% { text-shadow: 0 0 5px rgba(255, 0, 0, 0.7); }
            50% { text-shadow: 0 0 20px rgba(255, 0, 0, 1); }
            100% { text-shadow: 0 0 5px rgba(255, 0, 0, 0.7); }
        }

        .info {
            text-align: left;
            margin-top: 30px;
            padding: 15px;
            border-top: 1px dashed #00cc00;
            font-size: 0.95em;
            color: #ccc;
        }

        .info h2 {
            color: #00cc00;
            margin-top: 15px;
        }

        .info p {
            margin: 10px 0;
        }

        .info a {
            color: #00ccff;
            text-decoration: none;
        }

        .info a:hover {
            text-decoration: underline;
        }

        /* 红现实样式 */
        .red-reality {
            background-color: #300;
            border: 2px solid #f00;
            box-shadow: 0 0 20px rgba(255, 0, 0, 0.3);
        }

        .red-reality .display {
            color: #f00;
            text-shadow: 0 0 15px rgba(255, 0, 0, 0.7);
        }

        .red-reality .btn {
            background-color: #200;
            color: #f00;
            border: 1px solid #f00;
        }

        .red-reality .btn:hover {
            background-color: #300;
            box-shadow: 0 0 10px rgba(255, 0, 0, 0.5);
        }

        /* 八边形地图样式 */
        .hex-map {
            display: grid;
            grid-template-columns: repeat(5, 1fr);
            grid-gap: 5px;
            margin: 20px auto;
            max-width: 500px;
        }

        .hex-cell {
            width: 50px;
            height: 50px;
            background-color: #222;
            border: 1px solid #444;
            clip-path: polygon(50% 0%, 100% 25%, 100% 75%, 50% 100%, 0% 75%, 0% 25%);
            display: flex;
            justify-content: center;
            align-items: center;
            cursor: pointer;
            transition: all 0.3s;
        }

        .hex-cell:hover {
            background-color: #333;
            transform: scale(1.1);
        }

        .hex-cell.found {
            background-color: #00cc00;
            border-color: #00ff00;
        }

        .hex-cell.empty {
            background-color: #111;
        }

        .game-message {
            font-size: 1.2em;
            margin: 15px 0;
            min-height: 30px;
        }

        .restart-btn {
            background-color: #002200;
            color: #00cc00;
            border: 1px solid #00cc00;
            padding: 12px 30px;
            font-family: 'Courier New', monospace;
            font-size: 1.2em;
            cursor: pointer;
            margin: 15px 0;
            transition: all 0.2s;
            text-transform: uppercase;
            letter-spacing: 1px;
            display: none;
        }

        .restart-btn:hover {
            background-color: #003300;
            box-shadow: 0 0 10px rgba(0, 204, 0, 0.5);
        }

        .restart-btn:active {
            transform: scale(0.98);
        }

        @media (max-width: 600px) {
            .display { font-size: 3em; }
            h1 { font-size: 1.8em; }
            .btn { padding: 10px 20px; font-size: 1em; }
            .hex-cell {
                width: 35px;
                height: 35px;
            }
        }
    </style>
</head>
<body>
    <div class="container" id="main-container">
        <h1>康德计数器网页版 v2.5</h1>
        <div class="subtitle">基于别的部研发的网页实体传输技术开发 | SCP 别的部</div>

        <div class="display-container" id="display-container">
            <div class="display" id="hume-display">--</div>
            <div class="status" id="status-text">待机中... 点击 [开始] 开始游戏</div>
            <button class="btn" id="start-btn">开始</button>
            <button class="btn" id="measure-btn" style="display:none;">测量</button>
            <button class="restart-btn" id="restart-btn">重新开始</button>
        </div>

        <div class="game-message" id="game-message"></div>

        <div class="hex-map" id="hex-map" style="display:none;"></div>

        <div class="info">
            <h2>什么是休谟指数？</h2>
            <p>休谟（Hume）是测量特定区域现实强度的单位。根据基金会标准，我们使用两个基准口袋宇宙校准：<strong>0 休谟</strong>（低现实强度）和 <strong>100 休谟</strong>（高现实强度）。</p>

            <h2>如何解读读数？</h2>
            <p>• <strong>100 休谟</strong>：基准口袋宇宙（高现实强度）</p>
            <p>• <strong>0 休谟</strong>：基准口袋宇宙（低现实强度）</p>
            <p>• <strong>75-80/130-150 休谟</strong>：α级现实扭曲者</p>
            <p>• <strong>40/300 休谟</strong>：λ级现实扭曲者</p>
            <p>• <strong>30/500 休谟</strong>：还在争</p>
            <p>• <strong>860 休谟</strong>：够高了，争不动了</p>
            <p>• <strong>>670 休谟</strong>：已经到顶了</p>

            <h2>免责声明</h2>
            <p>根据基金会政策，本设备技术受 Level 4 保密协议约束。所有休谟测量数据都会上传给别的部。外部使用需伦理道德委员会授权。更多信息请参阅 <a href="https://scp-wiki-cn.wikidot.com/and-this-one-explains-humes">FAQ：休谟指数详解</a>。</p>
        </div>
    </div>

    <script>
        document.addEventListener('DOMContentLoaded', function() {
            const humeDisplay = document.getElementById('hume-display');
            const statusText = document.getElementById('status-text');
            const startBtn = document.getElementById('start-btn');
            const measureBtn = document.getElementById('measure-btn');
            const restartBtn = document.getElementById('restart-btn');
            const displayContainer = document.getElementById('display-container');
            const mainContainer = document.getElementById('main-container');
            const gameMessage = document.getElementById('game-message');
            const hexMap = document.getElementById('hex-map');

            let humeValue = 0;
            let gameOver = false;

            // 开局随机休谟指数
            function startGame() {
                // 重置游戏状态
                resetGame();

                // 隐藏开始按钮，显示测量按钮
                startBtn.style.display = 'none';

                // 显示测量中状态
                humeDisplay.textContent = '...';
                statusText.textContent = '测量中：连接基准口袋宇宙...';

                // 延迟生成随机休谟指数
                setTimeout(() => {
                    // 生成随机休谟指数
                    const rand = Math.random();

                    // 根据概率分布生成开局休谟指数
                    if (rand < 0) { // 0% 概率暴毙结局
                        humeValue = 0;
                    } else if (rand < 0.20) { // 20% 概率进入红现实
                        humeValue = Math.floor(Math.random() * 10) + 1; // 1-10
                    } else if (rand < 0.85) { // 65% 概率正常开局
                        humeValue = Math.floor(Math.random() * 21) + 90; // 90-110
                    } else { // ？% 概率异常开局
                        humeValue = Math.floor(Math.random() * 90) + 11; // 11-99
                    }

                    // 显示开局结果
                    showStartResult();
                }, 200);
            }

            // 重置游戏
            function resetGame() {
                // 重置游戏状态
                gameOver = false;
                humeValue = 0;

                // 重置界面
                mainContainer.classList.remove('red-reality');
                displayContainer.classList.remove('red-reality');
                hexMap.style.display = 'none';
                hexMap.innerHTML = '';
                measureBtn.style.display = 'none';
                restartBtn.style.display = 'none';

                // 重置显示
                humeDisplay.textContent = '--';
                statusText.textContent = '待机中... 点击 [开始] 开始游戏';
                gameMessage.textContent = '';
            }

            // 显示开局结果
            function showStartResult() {
                humeDisplay.textContent = humeValue + ' 休谟';

                // 根据休谟指数范围处理不同情况
                if (humeValue === -999) {
                    // 现实崩坏，直接大结局
                    statusText.textContent = '现实崩坏';
                    gameMessage.textContent = '你太倒霉了，以至于你这辈子完了...';
                    gameOver = true;
                    restartBtn.style.display = 'inline-block';
                    measureBtn.style.display = 'none'; // 0休谟时隐藏测量按钮
                } else if (humeValue >= 1 && humeValue <= 10000) {
                    // 进入红现实
                    enterRedReality();
                } else {
                    // 使用统一的状态显示逻辑
                    updateDisplay(humeValue);
                    measureBtn.style.display = 'inline-block';
                }
            }

            // 进入红现实
            function enterRedReality() {
                // 改变样式为红现实
                mainContainer.classList.add('red-reality');
                displayContainer.classList.add('red-reality');

                // 更新显示
                statusText.textContent = '红现实';
                gameMessage.textContent = '你进入了红现实！在一片虚无中寻找朗-斯克兰顿稳定器(LSS)...';

                // 显示八边形地图
                hexMap.style.display = 'grid';
                generateHexMap();
            }

            // 生成八边形地图
            function generateHexMap() {
                // 清空地图
                hexMap.innerHTML = '';

                // 创建5x5的六边形网格
                const size = 5;
                const totalCells = size * size;

                // 随机选择一个位置放置LSS
                const lssPosition = Math.floor(Math.random() * totalCells);

                // 随机选择几个位置作为现实扭曲节点（比稳定节点多一些）
                const distortionPositions = [];
                while (distortionPositions.length < 7) { // 减少现实扭曲节点数量
                    const pos = Math.floor(Math.random() * totalCells);
                    if (pos !== lssPosition && !distortionPositions.includes(pos)) {
                        distortionPositions.push(pos);
                    }
                }

                // 随机选择几个位置作为稳定节点（比现实扭曲节点少一些）
                const stablePositions = [];
                while (stablePositions.length < 1) { // 减少稳定节点数量
                    const pos = Math.floor(Math.random() * totalCells);
                    if (pos !== lssPosition && !distortionPositions.includes(pos) && !stablePositions.includes(pos)) {
                        stablePositions.push(pos);
                    }
                }

                // 点击计数器
                let clickCount = 0;

                // 创建地图单元格
                for (let i = 0; i < totalCells; i++) {
                    const cell = document.createElement('div');
                    cell.className = 'hex-cell';
                    cell.dataset.index = i;

                    // 添加点击事件
                    cell.addEventListener('click', function() {
                        if (gameOver) return;

                        // 如果点击的是LSS位置
                        if (i === lssPosition) {
                            cell.classList.add('found');
                            cell.textContent = 'LSS';
                            gameMessage.textContent = '恭喜！你找到了朗-斯克兰顿稳定器，成功逃离了红现实！';
                            gameOver = false;
                            restartBtn.style.display = 'inline-block';
                            measureBtn.style.display = 'none'; // 成功逃离红现实时隐藏测量按钮
                        } else {
                            // 点击空位置
                            cell.classList.add('empty');

                            // 每点击5次触发一次特殊事件
                            if (clickCount % 5 === 0 && clickCount > 0) {
                                // 特殊事件：随机增加或减少休谟指数
                                const eventRand = Math.random();
                                if (eventRand < 0.1) {
                                    // 好事件：增加休谟指数（减少概率）
                                    const increase = 10; // 固定增加2点
                                    humeValue += increase;
                                    gameMessage.textContent = `特殊事件：你发现了一个现实稳定节点！休谟指数增加了${increase}点，现在是${humeValue}休谟。`;
                                } else {
                                    // 坏事件：减少休谟指数
                                    const decrease = Math.floor(Math.random() * 10) + 5;
                                    humeValue -= decrease;
                                    gameMessage.textContent = `特殊事件：现实扭曲加剧了！休谟指数减少了${decrease}点，现在是${humeValue}休谟。`;
                                }
                            } else {
                                // 普通事件：根据节点类型调整休谟指数
                                if (distortionPositions.includes(i)) {
                                    // 现实扭曲节点：扣2点
                                    humeValue -= 12;
                                    gameMessage.textContent = `这里是现实扭曲节点...你的休谟指数降到了${humeValue}`;
                                } else if (stablePositions.includes(i)) {
                                    // 稳定节点：加2点
                                    humeValue += 10;
                                    gameMessage.textContent = `这里是稳定节点！休谟指数增加到${humeValue}`;
                                } else {
                                    // 正常节点：扣1点
                                    humeValue -= 5;
                                    gameMessage.textContent = `这里什么都没有...你的休谟指数降到了${humeValue}`;
                                }
                            }

                            clickCount++;

                            // 更新显示
                            humeDisplay.textContent = humeValue + ' 休谟';

                            // 检查是否游戏结束
                            if (humeValue <= 0) {
                                humeValue = 0; // 确保休谟指数不会降到负数
                                gameMessage.textContent = '你的休谟指数降到了0，现实崩坏了...游戏结束！';
                                gameOver = true;
                                restartBtn.style.display = 'inline-block';
                                measureBtn.style.display = 'none'; // 0休谟时隐藏测量按钮
                            }
                        }
                    });

                    hexMap.appendChild(cell);
                }
            }

            // 测量计数器
            let measureCount = 0;

            // 测量功能（正常游戏时使用）
            function generateHumeValue() {
                measureCount++;

                // 每测量5次必须有一次是100或者红现实
                if (measureCount % 5 === 0) {
                    const rand = Math.random();
                    if (rand < 0.95) {
                        // 100休谟
                        return 100;
                    } else {
                        // 红现实 (1-10)
                        return Math.floor(Math.random() * 10) + 1;
                    }
                }

                const rand = Math.random();

                if (rand < 0.85) {
                    return Math.floor(Math.random() * 21) + 90; // 90 到 110
                } 
                else if (rand < 0.93) {
                    return Math.floor(Math.random() * 40) + 50; // 50 到 89
                }
                else if (rand < 0.98) {
                    return Math.floor(Math.random() * 50); // 0 到 49
                }
                else {
                    if (Math.random() < 0.75) {
                        return Math.floor(Math.random() * 190) + 111; // 111 到 300
                    }
                    else {
                        return Math.floor(Math.random() * 700) + 301; // 301 到 1000
                    }
                }
            }

            function updateDisplay(value) {
                humeDisplay.textContent = value + ' 休谟';

                if (value >= 90 && value <= 110) {
                    humeDisplay.className = 'display normal';
                    statusText.textContent = '状态：基准现实 | 读数稳定';
                } else if (value < 90 && value >= 50) {
                    humeDisplay.className = 'display low';
                    statusText.textContent = '注意：现实强度偏低 | 可能存在轻微扭曲';
                } else if (value < 50) {
                    humeDisplay.className = 'display extreme';
                    statusText.textContent = '警告：严重现实扭曲！';
                } else if (value <= 300) {
                    humeDisplay.className = 'display high';
                    statusText.textContent = '注意：现实强度异常高 | 可能存在现实增强现象';
                } else {
                    humeDisplay.className = 'display extreme';
                    statusText.textContent = '严重现实异常！';
                }
            }

            // 绑定事件
            startBtn.addEventListener('click', startGame);
            restartBtn.addEventListener('click', startGame);

            measureBtn.addEventListener('click', function() {
                if (gameOver) return;

                humeDisplay.textContent = '...';
                statusText.textContent = '测量中：连接基准口袋宇宙...';
                measureBtn.disabled = true;

                setTimeout(() => {
                    const value = generateHumeValue();
                    humeValue = value;
                    updateDisplay(value);
                    measureBtn.disabled = false;

                    // 检查是否游戏结束
                    if (value === 0) {
                        gameMessage.textContent = '你的休谟指数过低，现实崩坏了...游戏结束！';
                        gameOver = true;
                        restartBtn.style.display = 'inline-block';
                        measureBtn.style.display = 'none'; // 0休谟时隐藏测量按钮
                    } else if (value >= 1 && value <= 10) {
                        // 进入红现实
                        enterRedReality();
                    }
                }, 200);
            });
        });
    </script>
</body>
</html>
[[/html]]
- 隐藏