Datasets:

Derur
/

all-portable-apps-and-ai-in-one-url

@@ -195,3 +195,4 @@ NeuroDonu/PortableSource(for[[:space:]]portables)/aria2c.exe filter=lfs diff=lfs
 NeuroDonu/PortableSource(for[[:space:]]portables)/onnxruntime_providers_cuda.dll filter=lfs diff=lfs merge=lfs -text
 NeuroDonu/PortableSource(for[[:space:]]portables)/onnxruntime_providers_tensorrt.dll filter=lfs diff=lfs merge=lfs -text
 HZ/База[[:space:]]знаний[[:space:]]SD.xlsx filter=lfs diff=lfs merge=lfs -text

 NeuroDonu/PortableSource(for[[:space:]]portables)/onnxruntime_providers_cuda.dll filter=lfs diff=lfs merge=lfs -text
 NeuroDonu/PortableSource(for[[:space:]]portables)/onnxruntime_providers_tensorrt.dll filter=lfs diff=lfs merge=lfs -text
 HZ/База[[:space:]]знаний[[:space:]]SD.xlsx filter=lfs diff=lfs merge=lfs -text
+NeuroPort/HTML+APPS/imagefix.exe filter=lfs diff=lfs merge=lfs -text

NeuroPort/HTML+APPS/AudioFileComparison.html ADDED Viewed

	@@ -0,0 +1,143 @@

+<!DOCTYPE html>
+<html lang="ru">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Сравнение аудиофайлов</title>
+    <script src="https://cdn.jsdelivr.net/npm/wavesurfer.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <style>
+        body { font-family: Arial, sans-serif; text-align: center; }
+        .waveform-container { display: flex; flex-direction: column; align-items: center; gap: 20px; }
+        .waveform { width: 80%; }
+        .waveform div { height: 150px; cursor: pointer; }
+        .chart-container { width: 80%; margin: auto; }
+        .audio-controls { margin-top: 20px; }
+    </style>
+</head>
+<body>
+    <h2>Сравнение двух аудиофайлов</h2>
+    <p>Нажмите <strong>1</strong> для воспроизведения первого трека, <strong>2</strong> для второго.</p>
+    <input type="file" id="file1" accept="audio/*" onchange="updateLabel(1)">
+    <input type="file" id="file2" accept="audio/*" onchange="updateLabel(2)">
+    <button onclick="analyzeAudio()">Анализировать</button>
+    <div class="waveform-container">
+        <div class="waveform">
+            <h3 id="track1-label">Файл 1</h3>
+            <div id="waveform1"></div>
+            <p id="time1">Время: 0:00</p>
+            <p id="rms1">RMS: -</p>
+            <p id="lufs1">LUFS: -</p>
+            <button onclick="playAudio(1)" style="font-size: 2em;">▶️/⏸</button>
+        </div>
+        <div class="waveform">
+            <h3 id="track2-label">Файл 2</h3>
+            <div id="waveform2"></div>
+            <p id="time2">Время: 0:00</p>
+            <p id="rms2">RMS: -</p>
+            <p id="lufs2">LUFS: -</p>
+            <button onclick="playAudio(2)" style="font-size: 2em;">▶️/⏸</button>
+        </div>
+    </div>
+    <canvas id="histogramChart"></canvas>
+    <canvas id="spectrumChart"></canvas>
+    <script>
+        let wavesurfer1, wavesurfer2;
+        document.addEventListener('keydown', function(event) {
+            if (event.key === '1') {
+                playAudio(1);
+            } else if (event.key === '2') {
+                playAudio(2);
+            }
+        });
+        function updateLabel(track) {
+            const fileInput = document.getElementById(`file${track}`);
+            const label = document.getElementById(`track${track}-label`);
+            label.textContent = fileInput.files[0] ? fileInput.files[0].name : `Файл ${track}`;
+        }
+        function analyzeAudio() {
+            const file1 = document.getElementById('file1').files[0];
+            const file2 = document.getElementById('file2').files[0];
+            if (!file1 || !file2) {
+                alert('Выберите два аудиофайла!');
+                return;
+            }
+            wavesurfer1 = WaveSurfer.create({ container: '#waveform1', waveColor: 'blue', progressColor: 'darkblue', height: 150 });
+            wavesurfer2 = WaveSurfer.create({ container: '#waveform2', waveColor: 'red', progressColor: 'darkred', height: 150 });
+            const url1 = URL.createObjectURL(file1);
+            const url2 = URL.createObjectURL(file2);
+            wavesurfer1.load(url1);
+            wavesurfer2.load(url2);
+            wavesurfer1.on('seek', syncSeek);
+            wavesurfer2.on('seek', syncSeek);
+            wavesurfer1.on('audioprocess', () => updateTime(1));
+            wavesurfer2.on('audioprocess', () => updateTime(2));
+            calculateLoudness(file1, 'rms1', 'lufs1');
+            calculateLoudness(file2, 'rms2', 'lufs2');
+        }
+        function playAudio(track) {
+            let otherWavesurfer = track === 1 ? wavesurfer2 : wavesurfer1;
+            let currentWavesurfer = track === 1 ? wavesurfer1 : wavesurfer2;
+            let currentTime = otherWavesurfer.getCurrentTime();
+            otherWavesurfer.pause();
+            currentWavesurfer.seekTo(currentTime / currentWavesurfer.getDuration());
+            currentWavesurfer.playPause();
+        }
+        function syncSeek() {
+            let time1 = wavesurfer1.getCurrentTime();
+            let time2 = wavesurfer2.getCurrentTime();
+            let avgTime = (time1 + time2) / 2;
+            wavesurfer1.seekTo(avgTime / wavesurfer1.getDuration());
+            wavesurfer2.seekTo(avgTime / wavesurfer2.getDuration());
+        }
+        function updateTime(track) {
+            let wavesurfer = track === 1 ? wavesurfer1 : wavesurfer2;
+            let timeElement = document.getElementById(`time${track}`);
+            let currentTime = wavesurfer.getCurrentTime();
+            timeElement.textContent = `Время: ${formatTime(currentTime)}`;
+        }
+        function formatTime(seconds) {
+            const minutes = Math.floor(seconds / 60);
+            const secs = Math.floor(seconds % 60);
+            return `${minutes}:${secs < 10 ? '0' : ''}${secs}`;
+        }
+        function calculateLoudness(file, rmsElementId, lufsElementId) {
+            const reader = new FileReader();
+            reader.readAsArrayBuffer(file);
+            reader.onload = function(event) {
+                const audioContext = new (window.AudioContext || window.webkitAudioContext)();
+                audioContext.decodeAudioData(event.target.result, function(buffer) {
+                    let data = buffer.getChannelData(0);
+                    let sum = 0;
+                    for (let i = 0; i < data.length; i++) {
+                        sum += data[i] * data[i];
+                    }
+                    let rms = Math.sqrt(sum / data.length);
+                    document.getElementById(rmsElementId).textContent = `RMS: ${rms.toFixed(6)}`;
+                    let lufs = 20 * Math.log10(rms);
+                    document.getElementById(lufsElementId).textContent = `LUFS: ${lufs.toFixed(2)}`;
+                });
+            };
+        }
+    </script>
+</body>
+</html>

NeuroPort/HTML+APPS/Image Compare.html ADDED Viewed

	@@ -0,0 +1,272 @@

+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Image Comparison Tool</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <style>
+        @keyframes pulse {
+            0%, 100% { opacity: 1; }
+            50% { opacity: 0.5; }
+        }
+        .animate-pulse {
+            animation: pulse 2s cubic-bezier(0.4, 0, 0.6, 1) infinite;
+        }
+        .bg-radial-gradient {
+            background-image: radial-gradient(circle at 50% 50%, rgba(76,29,149,0.3) 0%, rgba(0,0,0,0) 100%);
+        }
+    </style>
+</head>
+<body class="bg-gradient-to-b from-purple-900 to-black text-white min-h-screen">
+    <div class="w-full h-screen flex flex-col">
+        <div id="app" class="relative z-10 p-4 flex-1 flex flex-col">
+            <!-- Добавлен фон с градиентом -->
+            <div class="absolute inset-0 bg-black opacity-50">
+                <div class="absolute inset-0 bg-radial-gradient animate-pulse"></div>
+            </div>
+            <!-- Контент -->
+            <div class="relative">
+                <h1 class="text-3xl font-bold mb-4">🖼️ Image Compare</h1>
+                <p class="text-purple-300 mb-6">Система для сравнения изображений</p>
+                <!-- Секция автора -->
+                <div class="mb-6 space-y-2">
+                    <h2 class="text-xl text-purple-200 mb-2">Автор:</h2>
+                    <div>
+                        <a href="https://t.me/neuro_art0" class="text-purple-400 hover:text-purple-300 transition-colors duration-300"
+                           target="_blank" rel="noopener">Nerual Dreming</a> — Основатель
+                        <a href="https://artgeneration.me/" class="text-purple-400 hover:text-purple-300 transition-colors duration-300"
+                           target="_blank" rel="noopener">ArtGeneration.me</a>, техноблогер и нейро-евангелист
+                    </div>
+                </div>
+                <p class="text-purple-300 mb-6">
+                    Загрузите два изображения для сравнения. Используйте колесо мыши для приближения/отдаления и перетаскивание для позиционирования.
+                </p>
+                <!-- Поля загрузки файлов -->
+                <div class="mt-4 flex gap-4">
+                    <div class="flex-1">
+                        <label class="block text-sm font-medium mb-2 text-purple-300">Первое изображение</label>
+                        <input type="file" id="beforeInput" accept="image/*"
+                               class="block w-full text-sm text-purple-300 file:mr-4 file:py-2 file:px-4 file:rounded-full file:border-0 file:text-sm file:font-semibold file:bg-purple-500 file:text-white hover:file:bg-purple-400 file:transition-colors file:duration-200">
+                    </div>
+                    <div class="flex-1">
+                        <label class="block text-sm font-medium mb-2 text-purple-300">Второе изображение</label>
+                        <input type="file" id="afterInput" accept="image/*"
+                               class="block w-full text-sm text-purple-300 file:mr-4 file:py-2 file:px-4 file:rounded-full file:border-0 file:text-sm file:font-semibold file:bg-purple-500 file:text-white hover:file:bg-purple-400 file:transition-colors file:duration-200">
+                    </div>
+                </div>
+            </div>
+            <!-- Контейнер для сравнения -->
+            <div id="compareContainer" class="flex-1 relative w-full overflow-hidden bg-gray-900 bg-opacity-50 mt-4"
+                 style="display: none;">
+                <!-- Метаданные -->
+                <div class="absolute top-0 left-0 right-0 z-20 flex justify-between bg-black bg-opacity-50 backdrop-blur-sm px-4 py-2">
+                    <div class="flex flex-col">
+                        <span id="beforeFileName" class="text-purple-200 font-medium"></span>
+                        <span id="beforeMetadata" class="text-purple-300 text-sm"></span>
+                    </div>
+                    <div class="flex flex-col items-end">
+                        <span id="afterFileName" class="text-purple-200 font-medium"></span>
+                        <span id="afterMetadata" class="text-purple-300 text-sm"></span>
+                    </div>
+                </div>
+                <!-- Изображения -->
+                <div id="imageContainer" class="absolute inset-0">
+                    <div id="afterImage" class="absolute inset-0 bg-contain bg-center bg-no-repeat"></div>
+                    <div id="beforeImage" class="absolute inset-0 bg-contain bg-center bg-no-repeat"
+                         style="mask-image: linear-gradient(to right, black 50%, transparent 50%); -webkit-mask-image: linear-gradient(to right, black 50%, transparent 50%);"></div>
+                </div>
+                <!-- Слайдер -->
+                <div id="slider" class="absolute top-0 bottom-0 w-0.5 bg-purple-400 cursor-ew-resize z-10" style="left: 50%">
+                    <div class="slider-handle absolute top-1/2 left-1/2 transform -translate-x-1/2 -translate-y-1/2
+                                w-8 h-8 bg-gray-900 rounded-full shadow-lg flex items-center justify-center
+                                border-2 border-purple-400 cursor-ew-resize hover:shadow-purple-400/50">
+                        <svg class="w-6 h-6 text-purple-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 5l7 7-7 7"/>
+                        </svg>
+                    </div>
+                </div>
+            </div>
+            <!-- Placeholder -->
+            <div id="placeholder" class="flex-1 w-full border border-dashed border-purple-500/30 flex items-center justify-center bg-gray-900/20">
+                <div class="text-center space-y-4">
+                    <div class="w-24 h-24 mx-auto mb-4 rounded-full bg-purple-500/20 flex items-center justify-center animate-pulse">
+                        <svg class="w-12 h-12 text-purple-400" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
+                                  d="M4 16l4.586-4.586a2 2 0 012.828 0L16 16m-2-2l1.586-1.586a2 2 0 012.828 0L20 14m-6-6h.01M6 20h12a2 2 0 002-2V6a2 2 0 00-2-2H6a2 2 0 00-2 2v12a2 2 0 002 2z"/>
+                        </svg>
+                    </div>
+                    <p class="text-xl font-medium text-purple-300">Загрузите оба изображения для сравнения</p>
+                    <p class="text-purple-400">Используйте колесо мыши для масштабирования и перетаскивание для перемещения</p>
+                </div>
+            </div>
+        </div>
+    </div>
+    <script>
+        let state = {
+            beforeImage: null,
+            afterImage: null,
+            beforeFileName: '',
+            afterFileName: '',
+            beforeMetadata: null,
+            afterMetadata: null,
+            sliderPosition: 50,
+            isDragging: false,
+            isMoving: false,
+            position: { x: 0, y: 0 },
+            zoom: 1,
+            lastPosition: { x: 0, y: 0 }
+        };
+        function formatFileSize(bytes) {
+            if (bytes < 1024) return bytes + ' B';
+            if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' KB';
+            return (bytes / (1024 * 1024)).toFixed(1) + ' MB';
+        }
+        async function getImageMetadata(file, url) {
+            return new Promise(resolve => {
+                const img = new Image();
+                img.onload = () => {
+                    resolve({
+                        width: img.width,
+                        height: img.height,
+                        size: formatFileSize(file.size)
+                    });
+                };
+                img.src = url;
+            });
+        }
+        async function handleImageUpload(e, type) {
+            const file = e.target.files[0];
+            if (!file) return;
+            const reader = new FileReader();
+            reader.onload = async (e) => {
+                const imageUrl = e.target.result;
+                const metadata = await getImageMetadata(file, imageUrl);
+                if (type === 'before') {
+                    state.beforeImage = imageUrl;
+                    state.beforeFileName = file.name;
+                    state.beforeMetadata = metadata;
+                    document.getElementById('beforeFileName').textContent = file.name;
+                    document.getElementById('beforeMetadata').textContent =
+                        `${metadata.width}x${metadata.height}px • ${metadata.size}`;
+                } else {
+                    state.afterImage = imageUrl;
+                    state.afterFileName = file.name;
+                    state.afterMetadata = metadata;
+                    document.getElementById('afterFileName').textContent = file.name;
+                    document.getElementById('afterMetadata').textContent =
+                        `${metadata.width}x${metadata.height}px • ${metadata.size}`;
+                }
+                updateUI();
+            };
+            reader.readAsDataURL(file);
+        }
+        function updateUI() {
+            const container = document.getElementById('compareContainer');
+            const placeholder = document.getElementById('placeholder');
+            if (state.beforeImage && state.afterImage) {
+                container.style.display = 'block';
+                placeholder.style.display = 'none';
+                document.getElementById('beforeImage').style.backgroundImage = `url(${state.beforeImage})`;
+                document.getElementById('afterImage').style.backgroundImage = `url(${state.afterImage})`;
+                updateSlider();
+                updateTransform();
+            } else {
+                container.style.display = 'none';
+                placeholder.style.display = 'flex';
+            }
+        }
+        function updateSlider() {
+            const slider = document.getElementById('slider');
+            slider.style.left = `${state.sliderPosition}%`;
+            const compensated = getCompensatedSliderPosition();
+            document.getElementById('beforeImage').style.maskImage =
+                `linear-gradient(to right, black ${compensated}%, transparent ${compensated}%)`;
+            document.getElementById('beforeImage').style.webkitMaskImage =
+                `linear-gradient(to right, black ${compensated}%, transparent ${compensated}%)`;
+        }
+        function getCompensatedSliderPosition() {
+            const container = document.getElementById('compareContainer');
+            if (!container) return state.sliderPosition;
+            const containerWidth = container.clientWidth;
+            const zoomCompensation = ((state.zoom - 1) * (state.sliderPosition - 50)) / state.zoom;
+            const positionCompensation = (state.position.x / containerWidth) * 100 / state.zoom;
+            return state.sliderPosition - zoomCompensation - positionCompensation;
+        }
+        function updateTransform() {
+            const imageContainer = document.getElementById('imageContainer');
+            imageContainer.style.transform =
+                `translate3d(${state.position.x}px, ${state.position.y}px, 0) scale(${state.zoom})`;
+        }
+        document.addEventListener('DOMContentLoaded', () => {
+            const container = document.getElementById('compareContainer');
+            document.getElementById('beforeInput').addEventListener('change', e => handleImageUpload(e, 'before'));
+            document.getElementById('afterInput').addEventListener('change', e => handleImageUpload(e, 'after'));
+            container.addEventListener('mousedown', e => {
+                if (e.target.closest('.slider-handle')) {
+                    state.isDragging = true;
+                } else {
+                    state.isMoving = true;
+                    state.lastPosition = {
+                        x: e.clientX - state.position.x,
+                        y: e.clientY - state.position.y
+                    };
+                }
+            });
+            document.addEventListener('mouseup', () => {
+                state.isDragging = false;
+                state.isMoving = false;
+            });
+            document.addEventListener('mousemove', e => {
+                if (state.isDragging) {
+                    const rect = container.getBoundingClientRect();
+                    const x = e.clientX - rect.left;
+                    state.sliderPosition = Math.min(Math.max((x / rect.width) * 100, 0), 100);
+                    updateSlider();
+                } else if (state.isMoving) {
+                    state.position.x = e.clientX - state.lastPosition.x;
+                    state.position.y = e.clientY - state.lastPosition.y;
+                    updateTransform();
+                    updateSlider();
+                }
+            });
+            container.addEventListener('wheel', e => {
+                e.preventDefault();
+                state.zoom = Math.min(Math.max(state.zoom + (e.deltaY > 0 ? -0.1 : 0.1), 0.5), 5);
+                updateTransform();
+                updateSlider();
+            });
+        });
+    </script>
+</body>
+</html>

NeuroPort/HTML+APPS/LavaLamp_Black_v2.html ADDED Viewed

	@@ -0,0 +1,380 @@

+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>RGB Lava Lamp Screensaver</title>
+  <style>
+    body {
+      margin: 0;
+      padding: 0;
+      overflow: hidden;
+      background-color: #000;
+    }
+    .wrap {
+      overflow: hidden;
+      position: relative;
+      height: 100vh;
+      background-color: #000;
+    }
+    canvas {
+      width: 100%;
+      height: 100%;
+      filter: blur(3px);
+    }
+  </style>
+</head>
+<body>
+  <div class="wrap">
+    <canvas id="bubble"></canvas>
+  </div>
+  <script>
+    ;(function() {
+      "use strict";
+      var lavaLamps = [];
+      var colorCycles = [];
+      var ge1doot = {
+        screen: {
+          elem:     null,
+          callback: null,
+          ctx:      null,
+          width:    0,
+          height:   0,
+          left:     0,
+          top:      0,
+          init: function (id, callback, initRes) {
+            this.elem = document.getElementById(id);
+            this.callback = callback || null;
+            if (this.elem.tagName == "CANVAS") this.ctx = this.elem.getContext("2d");
+            window.addEventListener('resize', function () {
+              this.resize();
+            }.bind(this), false);
+            this.elem.onselectstart = function () { return false; }
+            this.elem.ondrag        = function () { return false; }
+            initRes && this.resize();
+            return this;
+          },
+          resize: function () {
+            var o = this.elem;
+            this.width  = o.offsetWidth;
+            this.height = o.offsetHeight;
+            for (this.left = 0, this.top = 0; o != null; o = o.offsetParent) {
+              this.left += o.offsetLeft;
+              this.top  += o.offsetTop;
+            }
+            if (this.ctx) {
+              this.elem.width  = this.width;
+              this.elem.height = this.height;
+            }
+            this.callback && this.callback();
+          }
+        }
+      }
+      // Color utility functions
+      function hslToRgb(h, s, l) {
+        var r, g, b;
+        if (s == 0) {
+          r = g = b = l;
+        } else {
+          function hue2rgb(p, q, t) {
+            if (t < 0) t += 1;
+            if (t > 1) t -= 1;
+            if (t < 1/6) return p + (q - p) * 6 * t;
+            if (t < 1/2) return q;
+            if (t < 2/3) return p + (q - p) * (2/3 - t) * 6;
+            return p;
+          }
+          var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+          var p = 2 * l - q;
+          r = hue2rgb(p, q, h + 1/3);
+          g = hue2rgb(p, q, h);
+          b = hue2rgb(p, q, h - 1/3);
+        }
+        return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];
+      }
+      function rgbToHex(r, g, b) {
+        return "#" + ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1);
+      }
+      // Color cycle class
+      var ColorCycle = function(h, s, l, speed) {
+        this.h = h;
+        this.s = s;
+        this.l = l;
+        this.speed = speed;
+        this.targetH = h;
+        this.currentH = h;
+      };
+      ColorCycle.prototype.update = function(dt) {
+        // Update target hue
+        this.targetH += this.speed * dt;
+        if (this.targetH > 1) this.targetH -= 1;
+        if (this.targetH < 0) this.targetH += 1;
+        // Smoothly interpolate current hue towards target (eases transitions)
+        var diff = this.targetH - this.currentH;
+        // Handle wrapping around 1
+        if (diff > 0.5) diff -= 1;
+        if (diff < -0.5) diff += 1;
+        // Smooth interpolation factor
+        this.currentH += diff * Math.min(1, dt * 3);
+        if (this.currentH > 1) this.currentH -= 1;
+        if (this.currentH < 0) this.currentH += 1;
+      };
+      ColorCycle.prototype.getColor = function() {
+        var rgb = hslToRgb(this.currentH, this.s, this.l);
+        return rgbToHex(rgb[0], rgb[1], rgb[2]);
+      };
+      // Point constructor
+      var Point = function(x, y) {
+        this.x = x;
+        this.y = y;
+        this.magnitude = x * x + y * y;
+        this.computed = 0;
+        this.force = 0;
+      };
+      Point.prototype.add = function(p) {
+        return new Point(this.x + p.x, this.y + p.y);
+      };
+      // Ball constructor with scaled speed and size
+      var Ball = function(parent) {
+        var min = .1;
+        var max = 1.5;
+        var scale = parent.wh / 1080; // Scale relative to Full HD
+        this.vel = new Point(
+          (Math.random() > 0.5 ? 1 : -1) * (0.05 + Math.random() * 0.1) * scale,
+          (Math.random() > 0.5 ? 1 : -1) * (0.05 + Math.random() * 0.1) * scale
+        );
+        this.pos = new Point(
+          parent.width * 0.2 + Math.random() * parent.width * 0.6,
+          parent.height * 0.2 + Math.random() * parent.height * 0.6
+        );
+        this.size = (parent.wh / 15) * scale + (Math.random() * (max - min) + min) * (parent.wh / 15) * scale;
+        this.width = parent.width;
+        this.height = parent.height;
+      };
+      // Move balls
+      Ball.prototype.move = function() {
+        if (this.pos.x >= this.width - this.size) {
+          if (this.vel.x > 0) this.vel.x = -this.vel.x;
+          this.pos.x = this.width - this.size;
+        } else if (this.pos.x <= this.size) {
+          if (this.vel.x < 0) this.vel.x = -this.vel.x;
+          this.pos.x = this.size;
+        }
+        if (this.pos.y >= this.height - this.size) {
+          if (this.vel.y > 0) this.vel.y = -this.vel.y;
+          this.pos.y = this.height - this.size;
+        } else if (this.pos.y <= this.size) {
+          if (this.vel.y < 0) this.vel.y = -this.vel.y;
+          this.pos.y = this.size;
+        }
+        this.pos = this.pos.add(this.vel);
+      };
+      // LavaLamp constructor with adaptive grid step
+      var LavaLamp = function(width, height, numBalls, colorTop, colorBottom) {
+        this.step = Math.floor(Math.min(width, height) / 100); // Adaptive grid step
+        this.width = width;
+        this.height = height;
+        this.wh = Math.min(width, height);
+        this.sx = Math.floor(this.width / this.step);
+        this.sy = Math.floor(this.height / this.step);
+        this.paint = false;
+        this.colorTop = colorTop;
+        this.colorBottom = colorBottom;
+        this.plx = [0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0];
+        this.ply = [0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1];
+        this.mscases = [0, 3, 0, 3, 1, 3, 0, 3, 2, 2, 0, 2, 1, 1, 0];
+        this.ix = [1, 0, -1, 0, 0, 1, 0, -1, -1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1];
+        this.grid = [];
+        this.balls = [];
+        this.iter = 0;
+        this.sign = 1;
+        for (var i = 0; i < (this.sx + 2) * (this.sy + 2); i++) {
+          this.grid[i] = new Point(
+            (i % (this.sx + 2)) * this.step, (Math.floor(i / (this.sx + 2))) * this.step
+          )
+        }
+        for (var k = 0; k < numBalls; k++) {
+          this.balls[k] = new Ball(this);
+        }
+      };
+      // Compute force
+      LavaLamp.prototype.computeForce = function(x, y, idx) {
+        var force;
+        var id = idx || x + y * (this.sx + 2);
+        if (x === 0 || y === 0 || x === this.sx || y === this.sy) {
+          force = 0.6 * this.sign;
+        } else {
+          force = 0;
+          var cell = this.grid[id];
+          var i = 0;
+          var ball;
+          while (ball = this.balls[i++]) {
+            force += ball.size * ball.size / (-2 * cell.x * ball.pos.x - 2 * cell.y * ball.pos.y + ball.pos.magnitude + cell.magnitude);
+          }
+          force *= this.sign
+        }
+        this.grid[id].force = force;
+        return force;
+      };
+      // Marching squares
+      LavaLamp.prototype.marchingSquares = function(next) {
+        var x = next[0];
+        var y = next[1];
+        var pdir = next[2];
+        var id = x + y * (this.sx + 2);
+        if (this.grid[id].computed === this.iter) {
+          return false;
+        }
+        var dir, mscase = 0;
+        for (var i = 0; i < 4; i++) {
+          var idn = (x + this.ix[i + 12]) + (y + this.ix[i + 16]) * (this.sx + 2);
+          var force = this.grid[idn].force;
+          if ((force > 0 && this.sign < 0) || (force < 0 && this.sign > 0) || !force) {
+            force = this.computeForce(
+              x + this.ix[i + 12],
+              y + this.ix[i + 16],
+              idn
+            );
+          }
+          if (Math.abs(force) > 1) mscase += Math.pow(2, i);
+        }
+        if (mscase === 15) {
+          return [x, y - 1, false];
+        } else {
+          if (mscase === 5) dir = (pdir === 2) ? 3 : 1;
+          else if (mscase === 10) dir = (pdir === 3) ? 0 : 2;
+          else {
+            dir = this.mscases[mscase];
+            this.grid[id].computed = this.iter;
+          }
+          var ix = this.step / (
+              Math.abs(Math.abs(this.grid[(x + this.plx[4 * dir + 2]) + (y + this.ply[4 * dir + 2]) * (this.sx + 2)].force) - 1) /
+              Math.abs(Math.abs(this.grid[(x + this.plx[4 * dir + 3]) + (y + this.ply[4 * dir + 3]) * (this.sx + 2)].force) - 1) + 1
+            );
+          ctx.lineTo(
+            this.grid[(x + this.plx[4 * dir]) + (y + this.ply[4 * dir]) * (this.sx + 2)].x + this.ix[dir] * ix,
+            this.grid[(x + this.plx[4 * dir + 1]) + (y + this.ply[4 * dir + 1]) * (this.sx + 2)].y + this.ix[dir + 4] * ix
+          );
+          this.paint = true;
+          return [
+            x + this.ix[dir + 4],
+            y + this.ix[dir + 8],
+            dir
+          ];
+        }
+      };
+      // Render metaballs with vertical gradient and enhanced effects
+      LavaLamp.prototype.renderMetaballs = function() {
+        var i = 0, ball;
+        while (ball = this.balls[i++]) ball.move();
+        this.iter++;
+        this.sign = -this.sign;
+        this.paint = false;
+        // Create vertical gradient for the metaball
+        var gradient = ctx.createLinearGradient(0, 0, 0, this.height);
+        gradient.addColorStop(0, this.colorTop);
+        gradient.addColorStop(1, this.colorBottom);
+        // Set fill style
+        ctx.fillStyle = gradient;
+        // Add shadow effect for inner glow (reduced blur for smoother transitions)
+        ctx.shadowBlur = 10;
+        ctx.shadowColor = this.colorBottom;
+        // Set blend mode for more vibrant colors
+        ctx.globalCompositeOperation = "lighter";
+        // Process each metaball
+        i = 0;
+        while (ball = this.balls[i++]) {
+          ctx.beginPath();
+          var next = [
+            Math.round(ball.pos.x / this.step),
+            Math.round(ball.pos.y / this.step), false
+          ];
+          do {
+            next = this.marchingSquares(next);
+          } while (next);
+          if (this.paint) {
+            ctx.fill();
+            ctx.closePath();
+            this.paint = false;
+          }
+        }
+        // Reset to standard blend mode
+        ctx.globalCompositeOperation = "source-over";
+        ctx.shadowBlur = 0;
+      };
+      // Main loop with refined motion blur
+      var lastTime = 0;
+      var run = function(time) {
+        var dt = (time - lastTime) / 1000;
+        // Limit dt to prevent large jumps if tab was inactive
+        dt = Math.min(dt, 0.1);
+        lastTime = time;
+        requestAnimationFrame(run);
+        // Apply more subtle motion blur effect for smoother animation
+        ctx.fillStyle = 'rgba(0, 0, 0, 0.9)';
+        ctx.fillRect(0, 0, screen.width, screen.height);
+        for (var i = 0; i < colorCycles.length; i++) {
+          colorCycles[i].update(dt);
+        }
+        for (var i = 0; i < lavaLamps.length; i++) {
+          var lamp = lavaLamps[i];
+          lamp.colorTop = colorCycles[0].getColor();
+          lamp.colorBottom = colorCycles[1].getColor();
+          lamp.renderMetaballs();
+        }
+      };
+      // Canvas initialization
+      var screen = ge1doot.screen.init("bubble", null, true),
+          ctx = screen.ctx;
+      screen.resize();
+      // Create color cycles with smoother transition speeds
+      colorCycles.push(new ColorCycle(0.6, 0.9, 0.5, 0.005)); // Cool colors (blue/purple/cyan) - slower transition
+      colorCycles.push(new ColorCycle(0.0, 0.9, 0.5, 0.008)); // Warm colors (red/orange/yellow) - slower transition
+      // Create LavaLamp with dynamic number of balls for 4K support
+      var numBalls = Math.min(20, Math.max(10, Math.floor(screen.width * screen.height / 1000000)));
+      lavaLamps.push(new LavaLamp(screen.width, screen.height, numBalls, "#0000FF", "#FF0000"));
+      // Start animation
+      requestAnimationFrame(run);
+    })();
+  </script>
+</body>
+</html>

NeuroPort/HTML+APPS/LavaLamp_RGB_v2.html ADDED Viewed

	@@ -0,0 +1,363 @@

+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Improved RGB Lava Lamp Screensaver</title>
+  <style>
+    body {
+      margin: 0;
+      padding: 0;
+      overflow: hidden;
+      background-color: #000;
+    }
+    .wrap {
+      overflow: hidden;
+      position: relative;
+      height: 100vh;
+      background-color: #000;
+    }
+    canvas {
+      width: 100%;
+      height: 100%;
+      filter: blur(3px);
+    }
+  </style>
+</head>
+<body>
+  <div class="wrap">
+    <canvas id="bubble"></canvas>
+  </div>
+  <script>
+    ;(function() {
+      "use strict";
+      var lavaLamps = [];
+      var colorCycles = [];
+      var ge1doot = {
+        screen: {
+          elem:     null,
+          callback: null,
+          ctx:      null,
+          width:    0,
+          height:   0,
+          left:     0,
+          top:      0,
+          init: function (id, callback, initRes) {
+            this.elem = document.getElementById(id);
+            this.callback = callback || null;
+            if (this.elem.tagName == "CANVAS") this.ctx = this.elem.getContext("2d");
+            window.addEventListener('resize', function () {
+              this.resize();
+            }.bind(this), false);
+            this.elem.onselectstart = function () { return false; }
+            this.elem.ondrag        = function () { return false; }
+            initRes && this.resize();
+            return this;
+          },
+          resize: function () {
+            var o = this.elem;
+            this.width  = o.offsetWidth;
+            this.height = o.offsetHeight;
+            for (this.left = 0, this.top = 0; o != null; o = o.offsetParent) {
+              this.left += o.offsetLeft;
+              this.top  += o.offsetTop;
+            }
+            if (this.ctx) {
+              this.elem.width  = this.width;
+              this.elem.height = this.height;
+            }
+            this.callback && this.callback();
+          }
+        }
+      }
+      // Color utility functions
+      function hslToRgb(h, s, l) {
+        var r, g, b;
+        if (s == 0) {
+          r = g = b = l;
+        } else {
+          function hue2rgb(p, q, t) {
+            if (t < 0) t += 1;
+            if (t > 1) t -= 1;
+            if (t < 1/6) return p + (q - p) * 6 * t;
+            if (t < 1/2) return q;
+            if (t < 2/3) return p + (q - p) * (2/3 - t) * 6;
+            return p;
+          }
+          var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+          var p = 2 * l - q;
+          r = hue2rgb(p, q, h + 1/3);
+          g = hue2rgb(p, q, h);
+          b = hue2rgb(p, q, h - 1/3);
+        }
+        return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];
+      }
+      function rgbToHex(r, g, b) {
+        return "#" + ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1);
+      }
+      // Color cycle class
+      var ColorCycle = function(h, s, l, speed) {
+        this.h = h;
+        this.s = s;
+        this.l = l;
+        this.speed = speed;
+      };
+      ColorCycle.prototype.update = function(dt) {
+        this.h += this.speed * dt;
+        if (this.h > 1) this.h -= 1;
+        if (this.h < 0) this.h += 1;
+      };
+      ColorCycle.prototype.getColor = function() {
+        var rgb = hslToRgb(this.h, this.s, this.l);
+        return rgbToHex(rgb[0], rgb[1], rgb[2]);
+      };
+      // Point constructor
+      var Point = function(x, y) {
+        this.x = x;
+        this.y = y;
+        this.magnitude = x * x + y * y;
+        this.computed = 0;
+        this.force = 0;
+      };
+      Point.prototype.add = function(p) {
+        return new Point(this.x + p.x, this.y + p.y);
+      };
+      // Ball constructor with scaled speed and size
+      var Ball = function(parent) {
+        var min = .1;
+        var max = 1.5;
+        var scale = parent.wh / 1080; // Scale relative to Full HD
+        this.vel = new Point(
+          (Math.random() > 0.5 ? 1 : -1) * (0.05 + Math.random() * 0.1) * scale,
+          (Math.random() > 0.5 ? 1 : -1) * (0.05 + Math.random() * 0.1) * scale
+        );
+        this.pos = new Point(
+          parent.width * 0.2 + Math.random() * parent.width * 0.6,
+          parent.height * 0.2 + Math.random() * parent.height * 0.6
+        );
+        this.size = (parent.wh / 15) * scale + (Math.random() * (max - min) + min) * (parent.wh / 15) * scale;
+        this.width = parent.width;
+        this.height = parent.height;
+      };
+      // Move balls
+      Ball.prototype.move = function() {
+        if (this.pos.x >= this.width - this.size) {
+          if (this.vel.x > 0) this.vel.x = -this.vel.x;
+          this.pos.x = this.width - this.size;
+        } else if (this.pos.x <= this.size) {
+          if (this.vel.x < 0) this.vel.x = -this.vel.x;
+          this.pos.x = this.size;
+        }
+        if (this.pos.y >= this.height - this.size) {
+          if (this.vel.y > 0) this.vel.y = -this.vel.y;
+          this.pos.y = this.height - this.size;
+        } else if (this.pos.y <= this.size) {
+          if (this.vel.y < 0) this.vel.y = -this.vel.y;
+          this.pos.y = this.size;
+        }
+        this.pos = this.pos.add(this.vel);
+      };
+      // LavaLamp constructor with adaptive grid step
+      var LavaLamp = function(width, height, numBalls, colorTop, colorBottom) {
+        this.step = Math.floor(Math.min(width, height) / 100); // Adaptive grid step
+        this.width = width;
+        this.height = height;
+        this.wh = Math.min(width, height);
+        this.sx = Math.floor(this.width / this.step);
+        this.sy = Math.floor(this.height / this.step);
+        this.paint = false;
+        this.colorTop = colorTop;
+        this.colorBottom = colorBottom;
+        this.plx = [0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0];
+        this.ply = [0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1];
+        this.mscases = [0, 3, 0, 3, 1, 3, 0, 3, 2, 2, 0, 2, 1, 1, 0];
+        this.ix = [1, 0, -1, 0, 0, 1, 0, -1, -1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1];
+        this.grid = [];
+        this.balls = [];
+        this.iter = 0;
+        this.sign = 1;
+        for (var i = 0; i < (this.sx + 2) * (this.sy + 2); i++) {
+          this.grid[i] = new Point(
+            (i % (this.sx + 2)) * this.step, (Math.floor(i / (this.sx + 2))) * this.step
+          )
+        }
+        for (var k = 0; k < numBalls; k++) {
+          this.balls[k] = new Ball(this);
+        }
+      };
+      // Compute force
+      LavaLamp.prototype.computeForce = function(x, y, idx) {
+        var force;
+        var id = idx || x + y * (this.sx + 2);
+        if (x === 0 || y === 0 || x === this.sx || y === this.sy) {
+          force = 0.6 * this.sign;
+        } else {
+          force = 0;
+          var cell = this.grid[id];
+          var i = 0;
+          var ball;
+          while (ball = this.balls[i++]) {
+            force += ball.size * ball.size / (-2 * cell.x * ball.pos.x - 2 * cell.y * ball.pos.y + ball.pos.magnitude + cell.magnitude);
+          }
+          force *= this.sign
+        }
+        this.grid[id].force = force;
+        return force;
+      };
+      // Marching squares
+      LavaLamp.prototype.marchingSquares = function(next) {
+        var x = next[0];
+        var y = next[1];
+        var pdir = next[2];
+        var id = x + y * (this.sx + 2);
+        if (this.grid[id].computed === this.iter) {
+          return false;
+        }
+        var dir, mscase = 0;
+        for (var i = 0; i < 4; i++) {
+          var idn = (x + this.ix[i + 12]) + (y + this.ix[i + 16]) * (this.sx + 2);
+          var force = this.grid[idn].force;
+          if ((force > 0 && this.sign < 0) || (force < 0 && this.sign > 0) || !force) {
+            force = this.computeForce(
+              x + this.ix[i + 12],
+              y + this.ix[i + 16],
+              idn
+            );
+          }
+          if (Math.abs(force) > 1) mscase += Math.pow(2, i);
+        }
+        if (mscase === 15) {
+          return [x, y - 1, false];
+        } else {
+          if (mscase === 5) dir = (pdir === 2) ? 3 : 1;
+          else if (mscase === 10) dir = (pdir === 3) ? 0 : 2;
+          else {
+            dir = this.mscases[mscase];
+            this.grid[id].computed = this.iter;
+          }
+          var ix = this.step / (
+              Math.abs(Math.abs(this.grid[(x + this.plx[4 * dir + 2]) + (y + this.ply[4 * dir + 2]) * (this.sx + 2)].force) - 1) /
+              Math.abs(Math.abs(this.grid[(x + this.plx[4 * dir + 3]) + (y + this.ply[4 * dir + 3]) * (this.sx + 2)].force) - 1) + 1
+            );
+          ctx.lineTo(
+            this.grid[(x + this.plx[4 * dir]) + (y + this.ply[4 * dir]) * (this.sx + 2)].x + this.ix[dir] * ix,
+            this.grid[(x + this.plx[4 * dir + 1]) + (y + this.ply[4 * dir + 1]) * (this.sx + 2)].y + this.ix[dir + 4] * ix
+          );
+          this.paint = true;
+          return [
+            x + this.ix[dir + 4],
+            y + this.ix[dir + 8],
+            dir
+          ];
+        }
+      };
+      // Render metaballs with vertical gradient and enhanced effects
+      LavaLamp.prototype.renderMetaballs = function() {
+        var i = 0, ball;
+        while (ball = this.balls[i++]) ball.move();
+        this.iter++;
+        this.sign = -this.sign;
+        this.paint = false;
+        // Создаем вертикальный градиент для всего метаболла
+        var gradient = ctx.createLinearGradient(0, 0, 0, this.height);
+        gradient.addColorStop(0, this.colorTop);
+        gradient.addColorStop(1, this.colorBottom);
+        // Устанавливаем стиль заливки
+        ctx.fillStyle = gradient;
+        // Добавляем эффект тени для внутреннего свечения
+        ctx.shadowBlur = 15;
+        ctx.shadowColor = this.colorBottom;
+        // Устанавливаем режим наложения для более ярких цвето��
+        ctx.globalCompositeOperation = "lighter";
+        // Обрабатываем каждый метаболл
+        i = 0;
+        while (ball = this.balls[i++]) {
+          ctx.beginPath();
+          var next = [
+            Math.round(ball.pos.x / this.step),
+            Math.round(ball.pos.y / this.step), false
+          ];
+          do {
+            next = this.marchingSquares(next);
+          } while (next);
+          if (this.paint) {
+            ctx.fill();
+            ctx.closePath();
+            this.paint = false;
+          }
+        }
+        // Возвращаем стандартный режим наложения
+        ctx.globalCompositeOperation = "source-over";
+      };
+      // Main loop with motion blur
+      var lastTime = 0;
+      var run = function(time) {
+        var dt = (time - lastTime) / 1000;
+        lastTime = time;
+        requestAnimationFrame(run);
+        // Применяем эффект motion blur для плавности движения
+        ctx.fillStyle = 'rgba(0, 0, 0, 0.8)';
+        ctx.fillRect(0, 0, screen.width, screen.height);
+        for (var i = 0; i < colorCycles.length; i++) {
+          colorCycles[i].update(dt);
+        }
+        for (var i = 0; i < lavaLamps.length; i++) {
+          var lamp = lavaLamps[i];
+          lamp.colorTop = colorCycles[0].getColor();
+          lamp.colorBottom = colorCycles[1].getColor();
+          lamp.renderMetaballs();
+        }
+      };
+      // Canvas initialization
+      var screen = ge1doot.screen.init("bubble", null, true),
+          ctx = screen.ctx;
+      screen.resize();
+      // Create color cycles with good values for RGB transitions
+      colorCycles.push(new ColorCycle(0.6, 0.9, 0.5, 0.01)); // Cool colors (blue/purple/cyan)
+      colorCycles.push(new ColorCycle(0.0, 0.9, 0.5, 0.02)); // Warm colors (red/orange/yellow)
+      // Create LavaLamp with dynamic number of balls for 4K support
+      var numBalls = Math.min(15, Math.max(8, Math.floor(screen.width * screen.height / 1000000)));
+      lavaLamps.push(new LavaLamp(screen.width, screen.height, numBalls, "#0000FF", "#FF0000"));
+      // Start animation
+      requestAnimationFrame(run);
+    })();
+  </script>
+</body>
+</html>

NeuroPort/HTML+APPS/Ping Pong/Ping Pong.html ADDED Viewed

	@@ -0,0 +1,434 @@

+<!DOCTYPE html>
+<html>
+<head>
+    <title>Pong Game</title>
+    <style>
+        body {
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            background: #1a1a1a;
+            margin: 0;
+            min-height: 100vh;
+            font-family: Arial, sans-serif;
+        }
+        canvas {
+            border: 2px solid #fff;
+            margin: 20px 0;
+        }
+        .menu {
+            margin: 20px;
+            text-align: center;
+        }
+        button {
+            padding: 10px 20px;
+            margin: 5px;
+            cursor: pointer;
+            background: #4CAF50;
+            border: none;
+            color: white;
+            border-radius: 4px;
+            font-size: 16px;
+        }
+        .game-over {
+            display: none;
+            position: fixed;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            font-size: 48px;
+            font-weight: bold;
+            color: white;
+            text-shadow: 2px 2px 4px rgba(0,0,0,0.5);
+            animation: zoom 1s infinite;
+            z-index: 1000;
+            text-align: center;
+        }
+        @keyframes zoom {
+            0% { transform: translate(-50%, -50%) scale(1); }
+            50% { transform: translate(-50%, -50%) scale(1.2); }
+            100% { transform: translate(-50%, -50%) scale(1); }
+        }
+        #fullscreenBtn {
+            position: fixed;
+            bottom: 20px;
+            left: 50%;
+            transform: translateX(-50%);
+            z-index: 1000;
+        }
+        .score {
+            position: fixed;
+            top: 20px;
+            font-size: 40px;
+            color: white;
+            transition: all 0.3s ease;
+        }
+        .score.changed {
+            transform: scale(1.5);
+            color: #4CAF50;
+        }
+        #leftPlayerName {
+            left: 20px;
+        }
+        #rightPlayerName {
+            right: 20px;
+        }
+        #playerNames {
+            position: fixed;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            background: rgba(0,0,0,0.8);
+            padding: 20px;
+            border-radius: 10px;
+            text-align: center;
+            color: white;
+            z-index: 1001;
+        }
+        #playerNames input {
+            margin: 10px;
+            padding: 8px;
+            font-size: 16px;
+            width: 200px;
+        }
+        .player-name {
+            position: fixed;
+            top: 80px;
+            font-size: 24px;
+            color: white;
+            text-shadow: 2px 2px 4px rgba(0,0,0,0.5);
+        }
+		.goal-effect {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background: rgba(255,255,255,0.3);
+            animation: blink 0.5s linear 2;
+            pointer-events: none;
+            display: none;
+        }
+		@keyframes blink {
+            0%, 100% { opacity: 0; }
+            50% { opacity: 1; }
+        }
+    </style>
+</head>
+<body>
+    <div id="playerNames">
+        <h2>Введите имена игроков</h2>
+        <input type="text" id="leftPlayer" placeholder="Левый игрок">
+        <input type="text" id="rightPlayer" placeholder="Правый игрок"><br>
+        <button onclick="startGame()">Начать игру</button>
+    </div>
+    <div class="goal-effect" id="goalEffect"></div>
+    <div class="player-name" id="leftPlayerName"></div>
+    <div class="player-name" id="rightPlayerName"></div>
+    <div class="score" id="leftScore" style="left: 20px;">0</div>
+    <div class="score" id="rightScore" style="right: 20px;">0</div>
+    <button id="fullscreenBtn" onclick="toggleFullscreen()">⛶</button>
+    <canvas id="gameCanvas" width="800" height="500"></canvas>
+    <div id="gameOver" class="game-over"></div>
+    <!-- Звуковые файлы -->
+    <audio id="paddleSound" src="paddle_hit.wav"></audio>
+    <audio id="obstacleSound" src="obstacle_hit.wav"></audio>
+    <audio id="winSound" src="win_sound.wav"></audio>
+    <audio id="goalSound" src="goal.wav"></audio>
+<script>
+const canvas = document.getElementById('gameCanvas');
+const ctx = canvas.getContext('2d');
+const gameOverElement = document.getElementById('gameOver');
+const playerNamesDiv = document.getElementById('playerNames');
+const leftPlayerNameElement = document.getElementById('leftPlayerName');
+const rightPlayerNameElement = document.getElementById('rightPlayerName');
+const leftScoreElement = document.getElementById('leftScore');
+const rightScoreElement = document.getElementById('rightScore');
+// Аудио элементы
+const paddleSound = document.getElementById('paddleSound');
+const obstacleSound = document.getElementById('obstacleSound');
+const winSound = document.getElementById('winSound');
+const goalSound = document.getElementById('goalSound');
+// Игровые переменные
+let gameMode = '';
+let isPlaying = false;
+let obstacles = [];
+const obstacleTypes = ['paddle', 'ball', 'random'];
+let leftPlayerName = 'Левый игрок';
+let rightPlayerName = 'Правый игрок';
+// Таймеры для препятствий
+let lastObstacleTime = 0;
+const OBSTACLE_INTERVAL = 5000;
+const OBSTACLE_LIFETIME = 30000;
+// Размеры объектов
+let paddleHeight = 80;
+const paddleWidth = 10;
+const ballSize = 8;
+// Позиции и скорости
+let leftPaddleY = canvas.height/2 - paddleHeight/2;
+let rightPaddleY = canvas.height/2 - paddleHeight/2;
+let ballX = canvas.width/2;
+let ballY = canvas.height/2;
+let ballSpeedX = 5;
+let ballSpeedY = 3;
+let scoreLeft = 0;
+let scoreRight = 0;
+// Состояния клавиш
+const keys = {
+    w: false,
+    s: false,
+    ArrowUp: false,
+    ArrowDown: false
+};
+function showGoalEffect() {
+    const effect = document.getElementById('goalEffect');
+    effect.style.display = 'block';
+    setTimeout(() => {
+        effect.style.display = 'none';
+    }, 1000);
+}
+function startGame() {
+    leftPlayerName = document.getElementById('leftPlayer').value || 'Левый игрок';
+    rightPlayerName = document.getElementById('rightPlayer').value || 'Правый игрок';
+    gameMode = 'hard';
+    playerNamesDiv.style.display = 'none';
+    initGame();
+}
+function initGame() {
+    isPlaying = true;
+    obstacles = [];
+    scoreLeft = 0;
+    scoreRight = 0;
+    lastObstacleTime = 0;
+    paddleHeight = 80;
+    leftPlayerNameElement.textContent = leftPlayerName;
+    rightPlayerNameElement.textContent = rightPlayerName;
+    leftScoreElement.textContent = '0';
+    rightScoreElement.textContent = '0';
+    resetBall();
+    gameLoop();
+}
+function resetBall() {
+    ballX = canvas.width/2;
+    ballY = canvas.height/2;
+    ballSpeedX = Math.random() > 0.5 ? 5 : -5;
+    ballSpeedY = 3;
+}
+function createObstacle() {
+    if (gameMode === 'hard' && Date.now() - lastObstacleTime > OBSTACLE_INTERVAL) {
+        const type = obstacleTypes[Math.floor(Math.random() * obstacleTypes.length)];
+        obstacles.push({
+            type: type,
+            x: Math.random() * (canvas.width - 40),
+            y: Math.random() * (canvas.height - 40),
+            width: 40,
+            height: 40,
+            createdAt: Date.now(),
+            color: type === 'paddle' ? (Math.random() > 0.5 ? 'red' : 'green') :
+                   type === 'ball' ? ['red', 'blue', 'green'][Math.floor(Math.random()*3)] : 'yellow',
+            rotation: 0
+        });
+        lastObstacleTime = Date.now();
+    }
+}
+function handleObstacles() {
+    const now = Date.now();
+    obstacles = obstacles.filter(obs => now - obs.createdAt < OBSTACLE_LIFETIME);
+    obstacles.forEach((obs, index) => {
+        if (obs.type === 'random') obs.rotation += 0.1;
+        if (ballX + ballSize > obs.x &&
+            ballX < obs.x + obs.width &&
+            ballY + ballSize > obs.y &&
+            ballY < obs.y + obs.height) {
+            obstacleSound.currentTime = 0;
+            obstacleSound.play();
+            switch(obs.type) {
+                case 'paddle':
+                    paddleHeight = obs.color === 'red' ? 60 : 100;
+                    break;
+                case 'ball':
+                    if(obs.color === 'red') {
+                        ballSpeedX *= 1.5;
+                        ballSpeedY *= 1.5;
+                    } else if(obs.color === 'blue') {
+                        ballSpeedX *= 0.7;
+                        ballSpeedY *= 0.7;
+                    } else {
+                        ballSpeedX *= -1;
+                    }
+                    break;
+                case 'random':
+                    ballSpeedX = (Math.random() - 0.5) * 10;
+                    ballSpeedY = (Math.random() - 0.5) * 10;
+                    break;
+            }
+            obstacles.splice(index, 1);
+        }
+    });
+}
+function drawObstacle(obs) {
+    ctx.save();
+    ctx.translate(obs.x + obs.width/2, obs.y + obs.height/2);
+    ctx.rotate(obs.rotation);
+    switch(obs.type) {
+        case 'paddle':
+            ctx.fillStyle = obs.color;
+            ctx.fillRect(-obs.width/2, -obs.height/2, obs.width, obs.height);
+            break;
+        case 'ball':
+            ctx.beginPath();
+            ctx.arc(0, 0, obs.width/2, 0, Math.PI*2);
+            ctx.fillStyle = obs.color;
+            ctx.fill();
+            break;
+        case 'random':
+            ctx.beginPath();
+            for(let i = 0; i < 5; i++) {
+                const angle = i * Math.PI*2/5;
+                const x = Math.cos(angle) * obs.width/2;
+                const y = Math.sin(angle) * obs.height/2;
+                if(i === 0) ctx.moveTo(x, y);
+                else ctx.lineTo(x, y);
+            }
+            ctx.closePath();
+            ctx.fillStyle = obs.color;
+            ctx.fill();
+            break;
+    }
+    ctx.restore();
+}
+function animateScore(isLeft) {
+    const element = isLeft ? leftScoreElement : rightScoreElement;
+    element.classList.add('changed');
+    setTimeout(() => element.classList.remove('changed'), 300);
+}
+function gameLoop() {
+    if (!isPlaying) return;
+    // Движение ракеток
+    if (keys.w && leftPaddleY > 0) leftPaddleY -= 5;
+    if (keys.s && leftPaddleY < canvas.height - paddleHeight) leftPaddleY += 5;
+    if (keys.ArrowUp && rightPaddleY > 0) rightPaddleY -= 5;
+    if (keys.ArrowDown && rightPaddleY < canvas.height - paddleHeight) rightPaddleY += 5;
+    // Движение мяча
+    ballX += ballSpeedX;
+    ballY += ballSpeedY;
+    // Отскок от стен
+    if (ballY < 0 || ballY > canvas.height - ballSize) ballSpeedY *= -1;
+    // Столкновение с ракетками
+    if ((ballX < paddleWidth && ballY > leftPaddleY && ballY < leftPaddleY + paddleHeight) ||
+        (ballX > canvas.width - paddleWidth - ballSize && ballY > rightPaddleY && ballY < rightPaddleY + paddleHeight)) {
+        paddleSound.currentTime = 0;
+        paddleSound.play();
+        ballSpeedX *= -1;
+        ballSpeedY += (Math.random() - 0.5) * 2;
+    }
+    // Гол
+    if (ballX < 0 || ballX > canvas.width) {
+    goalSound.currentTime = 0;
+    goalSound.play();
+    showGoalEffect(); // Добавляем эффект
+    if(ballX < 0) {
+        scoreRight++;
+        rightScoreElement.textContent = scoreRight;
+        animateScore(false);
+    } else {
+        scoreLeft++;
+        leftScoreElement.textContent = scoreLeft;
+        animateScore(true);
+    }
+    resetBall();
+}
+    // Обработка препятствий
+    createObstacle();
+    handleObstacles();
+    // Проверка победы
+    if (scoreLeft >= 10 || scoreRight >= 10) {
+        isPlaying = false;
+        gameOverElement.style.display = 'block';
+        const winner = scoreLeft >= 10 ? leftPlayerName : rightPlayerName;
+        gameOverElement.innerHTML = `Победитель:<br>${winner}!`;
+        winSound.currentTime = 0;
+        winSound.play();
+        return;
+    }
+    // Отрисовка
+    ctx.fillStyle = 'black';
+    ctx.fillRect(0, 0, canvas.width, canvas.height);
+    // Ракетки
+    ctx.fillStyle = 'white';
+    ctx.fillRect(0, leftPaddleY, paddleWidth, paddleHeight);
+    ctx.fillRect(canvas.width - paddleWidth, rightPaddleY, paddleWidth, paddleHeight);
+    // Мяч
+    ctx.beginPath();
+    ctx.arc(ballX + ballSize/2, ballY + ballSize/2, ballSize, 0, Math.PI*2);
+    ctx.fill();
+    // Препятствия
+    obstacles.forEach(obs => {
+        const timeLeft = OBSTACLE_LIFETIME - (Date.now() - obs.createdAt);
+        const alpha = Math.min(1, timeLeft / 2000);
+        ctx.globalAlpha = alpha;
+        drawObstacle(obs);
+        ctx.globalAlpha = 1;
+    });
+    requestAnimationFrame(gameLoop);
+}
+function toggleFullscreen() {
+    if (!document.fullscreenElement) {
+        canvas.requestFullscreen().catch(err => {
+            alert(`Ошибка при переходе в полноэкранный режим: ${err.message}`);
+        });
+    } else {
+        document.exitFullscreen();
+    }
+}
+// Обработчики событий
+document.addEventListener('keydown', (e) => {
+    if (keys.hasOwnProperty(e.key)) keys[e.key] = true;
+});
+document.addEventListener('keyup', (e) => {
+    if (keys.hasOwnProperty(e.key)) keys[e.key] = false;
+});
+</script>
+</body>
+</html>

NeuroPort/HTML+APPS/Ping Pong/goal.wav ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:e843facc6fa60a90f320cf62be60ff87cbb77f538baf4a54162577fa162c2cd1
+size 1049690

NeuroPort/HTML+APPS/Ping Pong/obstacle_hit.wav ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:a26a859cbe6186c5f161f23e1a35f8abfa3c713ec76a057a5880f996cd38ed1d
+size 24861

NeuroPort/HTML+APPS/Ping Pong/paddle_hit.wav ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:afca939a180777dcfe5e73761dbbfe0b245e5a81e79d95819b00fe4957a03f64
+size 2310

NeuroPort/HTML+APPS/Ping Pong/win_sound.wav ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:82b37edf577a920982d6654bad7654fc9282445f4e75bf2ec235de823d4b2473
+size 1001562

NeuroPort/HTML+APPS/imagefix.exe ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:6d7137e04c19973ff78de355373ab430874c55a2a7b47a0e56f9d80bfabd58a2
+size 10304000

NeuroPort/HTML+APPS/mp4towebm.html ADDED Viewed

	@@ -0,0 +1,110 @@

+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>MP4 to WebM Converter</title>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            max-width: 600px;
+            margin: 20px auto;
+            padding: 20px;
+        }
+        .container {
+            border: 2px dashed #ccc;
+            padding: 20px;
+            text-align: center;
+        }
+        #preview {
+            max-width: 100%;
+            margin-top: 20px;
+        }
+        .hidden {
+            display: none;
+        }
+        button {
+            padding: 10px 20px;
+            background: #4CAF50;
+            color: white;
+            border: none;
+            cursor: pointer;
+            margin: 10px;
+        }
+        button:disabled {
+            background: #cccccc;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h2>MP4 to WebM Converter</h2>
+        <input type="file" id="fileInput" accept="video/mp4">
+        <button id="convertBtn" disabled>Convert to WebM</button>
+        <a id="downloadLink" class="hidden"><button>Download WebM</button></a>
+        <video id="preview" controls></video>
+    </div>
+    <script>
+        const fileInput = document.getElementById('fileInput');
+        const convertBtn = document.getElementById('convertBtn');
+        const downloadLink = document.getElementById('downloadLink');
+        const preview = document.getElementById('preview');
+        let mediaRecorder;
+        let recordedChunks = [];
+        fileInput.addEventListener('change', async (e) => {
+            const file = e.target.files[0];
+            if (!file) return;
+            const url = URL.createObjectURL(file);
+            preview.src = url;
+            convertBtn.disabled = false;
+        });
+        convertBtn.addEventListener('click', async () => {
+            if (!preview.src) return;
+            try {
+                convertBtn.disabled = true;
+                convertBtn.textContent = 'Converting...';
+                const stream = await preview.captureStream();
+                recordedChunks = [];
+                mediaRecorder = new MediaRecorder(stream, {
+                    mimeType: 'video/webm; codecs=vp9'
+                });
+                mediaRecorder.ondataavailable = (e) => {
+                    if (e.data.size > 0) recordedChunks.push(e.data);
+                };
+                mediaRecorder.onstop = () => {
+                    const blob = new Blob(recordedChunks, { type: 'video/webm' });
+                    const url = URL.createObjectURL(blob);
+                    downloadLink.href = url;
+                    downloadLink.download = `converted_${Date.now()}.webm`;
+                    downloadLink.classList.remove('hidden');
+                    convertBtn.textContent = 'Convert to WebM';
+                    convertBtn.disabled = false;
+                };
+                mediaRecorder.start();
+                preview.play();
+                // Остановить запись после завершения видео
+                preview.addEventListener('ended', () => {
+                    mediaRecorder.stop();
+                });
+            } catch (error) {
+                console.error('Conversion error:', error);
+                alert('Error during conversion: ' + error.message);
+                convertBtn.textContent = 'Convert to WebM';
+                convertBtn.disabled = false;
+            }
+        });
+    </script>
+</body>
+</html>

NeuroPort/HTML+APPS/optimized-lava-lamp.html ADDED Viewed

	@@ -0,0 +1,161 @@

+<!DOCTYPE html>
+<html>
+<head>
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+    <style>
+        body {
+            margin: 0;
+            overflow: hidden;
+            background: #000;
+        }
+        .lava-container {
+            position: fixed;
+            width: 100vw;
+            height: 100vh;
+            background: #000;
+            /* Предварительный рендеринг */
+            contain: layout size;
+        }
+        .lava-blob {
+            position: absolute;
+            border-radius: 50%;
+            /* Уменьшаем радиус размытия */
+            filter: blur(calc(1.5vw + 1.5vh));
+            mix-blend-mode: screen;
+            opacity: 0.6;
+            /* Подсказка браузеру об оптимизации */
+            will-change: transform;
+            /* Принудительное аппаратное ускорение */
+            transform: translateZ(0);
+        }
+        /* Предварительно определяем только 4 ключевых блоба */
+        .blob1 {
+            width: 30vw;
+            height: 30vw;
+            background: #8b0046;
+            animation: float1 25s ease-in-out infinite;
+        }
+        .blob2 {
+            width: 35vw;
+            height: 35vw;
+            background: #004b8c;
+            animation: float2 28s ease-in-out infinite;
+        }
+        .blob3 {
+            width: 25vw;
+            height: 25vw;
+            background: #4b0082;
+            animation: float3 24s ease-in-out infinite;
+        }
+        .blob4 {
+            width: 40vw;
+            height: 40vw;
+            background: #006400;
+            animation: float4 30s ease-in-out infinite;
+        }
+        /* Отдельные анимации для каждого блоба */
+        @keyframes float1 {
+            0% { transform: translate(10vw, 10vh) scale(1) translateZ(0); }
+            25% { transform: translate(60vw, 30vh) scale(1.1) translateZ(0); }
+            50% { transform: translate(50vw, 60vh) scale(0.9) translateZ(0); }
+            75% { transform: translate(20vw, 40vh) scale(1.05) translateZ(0); }
+            100% { transform: translate(10vw, 10vh) scale(1) translateZ(0); }
+        }
+        @keyframes float2 {
+            0% { transform: translate(60vw, 20vh) scale(1) translateZ(0); }
+            30% { transform: translate(20vw, 40vh) scale(1.1) translateZ(0); }
+            60% { transform: translate(40vw, 60vh) scale(0.9) translateZ(0); }
+            100% { transform: translate(60vw, 20vh) scale(1) translateZ(0); }
+        }
+        @keyframes float3 {
+            0% { transform: translate(30vw, 70vh) scale(1) translateZ(0); }
+            40% { transform: translate(70vw, 30vh) scale(1.05) translateZ(0); }
+            80% { transform: translate(20vw, 50vh) scale(0.95) translateZ(0); }
+            100% { transform: translate(30vw, 70vh) scale(1) translateZ(0); }
+        }
+        @keyframes float4 {
+            0% { transform: translate(70vw, 60vh) scale(1) translateZ(0); }
+            33% { transform: translate(20vw, 20vh) scale(1.1) translateZ(0); }
+            66% { transform: translate(50vw, 40vh) scale(0.9) translateZ(0); }
+            100% { transform: translate(70vw, 60vh) scale(1) translateZ(0); }
+        }
+        .overlay {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100vw;
+            height: 100vh;
+            background: radial-gradient(circle at center, transparent 0%, rgba(0,0,0,0.4) 100%);
+            pointer-events: none;
+        }
+    </style>
+</head>
+<body>
+    <div class="lava-container">
+        <div class="lava-blob blob1"></div>
+        <div class="lava-blob blob2"></div>
+        <div class="lava-blob blob3"></div>
+        <div class="lava-blob blob4"></div>
+        <div class="overlay"></div>
+    </div>
+    <script>
+        const container = document.querySelector('.lava-container');
+        const colors = [
+            '#8b0046', // Глубокий малиновый
+            '#004b8c', // Глубокий синий
+            '#4b0082', // Индиго
+            '#006400', // Темно-зеленый
+            '#800080', // Пурпурный
+            '#00458b', // Темно-голубой
+            '#8b4500', // Темно-оранжевый
+            '#2f4f4f'  // Темно-бирюзовый
+        ];
+        // Создаем максимум 5 дополнительных блобов, независимо от размера экрана
+        const maxExtraBlobs = 5;
+        const extraBlobsCount = Math.min(
+            Math.floor(Math.max(window.innerWidth, window.innerHeight) / 600) + 1,
+            maxExtraBlobs
+        );
+        // Создаем дополнительные блобы только при начальной загрузке
+        for (let i = 0; i < extraBlobsCount; i++) {
+            const blob = document.createElement('div');
+            blob.className = 'lava-blob';
+            // Делаем дополнительные блобы меньше основных
+            const size = Math.random() * 15 + 15 + 'vw';
+            blob.style.width = size;
+            blob.style.height = size;
+            blob.style.background = colors[Math.floor(Math.random() * colors.length)];
+            // Создаем для них простые анимации через CSS
+            blob.style.left = Math.random() * 70 + 10 + 'vw';
+            blob.style.top = Math.random() * 70 + 10 + 'vh';
+            // Добавляем простую анимацию пульсации
+            const duration = (Math.random() * 5 + 20) + 's';
+            const delay = (Math.random() * -15) + 's';
+            blob.style.animation = `float${i % 4 + 1} ${duration} ease-in-out infinite`;
+            blob.style.animationDelay = delay;
+            container.appendChild(blob);
+        }
+        // Никаких обработчиков движения мыши - это просто статический экран
+    </script>
+</body>
+</html>

NeuroPort/HTML+APPS/waveform_audio_player.html ADDED Viewed

	@@ -0,0 +1,184 @@

+<!DOCTYPE html>
+<html>
+<head>
+    <title>Волновая форма аудио</title>
+    <style>
+        canvas {
+            border: 1px solid #ddd;
+            width: 100%;
+            height: 200px;
+        }
+    </style>
+</head>
+<body>
+    <input type="file" id="audio-file" accept="audio/*">
+    <canvas id="waveform"></canvas>
+    <div id="controls">
+        <button id="play">Play</button>
+        <button id="stop">Stop</button>
+    </div>
+    <script>
+        const audioFile = document.getElementById('audio-file');
+        const canvas = document.getElementById('waveform');
+        const ctx = canvas.getContext('2d');
+        const playButton = document.getElementById('play');
+        const stopButton = document.getElementById('stop');
+        let audioBuffer;
+        let audioSource;
+        let startTime;
+        let animationFrameId;
+        let offscreenCanvas;
+        let offscreenCtx;
+        audioFile.addEventListener('change', handleFileSelect, false);
+        playButton.addEventListener('click', playAudio);
+        stopButton.addEventListener('click', stopAudio);
+        canvas.addEventListener('click', seekAudio);
+        function handleFileSelect(event) {
+            const file = event.target.files[0];
+            const reader = new FileReader();
+            reader.onload = function(event) {
+                const audioContext = new (window.AudioContext || window.webkitAudioContext)();
+                audioContext.decodeAudioData(event.target.result, buffer => {
+                    audioBuffer = buffer;
+                    resizeCanvas();
+                    createOffscreenCanvas();
+                    drawOffscreenWaveform();
+                    drawWaveform();
+                });
+            };
+            reader.readAsArrayBuffer(file);
+        }
+        function resizeCanvas() {
+            const dpr = window.devicePixelRatio || 1;
+            const rect = canvas.getBoundingClientRect();
+            canvas.width = rect.width * dpr;
+            canvas.height = rect.height * dpr;
+            ctx.scale(dpr, dpr);
+        }
+        function createOffscreenCanvas() {
+            offscreenCanvas = document.createElement('canvas');
+            offscreenCanvas.width = canvas.width;
+            offscreenCanvas.height = canvas.height;
+            offscreenCtx = offscreenCanvas.getContext('2d');
+        }
+        function drawOffscreenWaveform() {
+            if (!audioBuffer) return;
+            const channelData = audioBuffer.getChannelData(0);
+            const length = channelData.length;
+            const canvasWidth = offscreenCanvas.width;
+            const canvasHeight = offscreenCanvas.height;
+            const step = Math.ceil(length / canvasWidth);
+            offscreenCtx.clearRect(0, 0, canvasWidth, canvasHeight);
+            offscreenCtx.beginPath();
+            for (let i = 0; i < canvasWidth; i++) {
+                let min = 1.0;
+                let max = -1.0;
+                for (let j = 0; j < step; j++) {
+                    const sample = channelData[Math.floor(i * step + j)];
+                    if (sample < min) min = sample;
+                    if (sample > max) max = sample;
+                }
+                const x = i;
+                const minY = (1 - min) * (canvasHeight / 2);
+                const maxY = (1 - max) * (canvasHeight / 2);
+                offscreenCtx.moveTo(x, minY);
+                offscreenCtx.lineTo(x, maxY);
+            }
+            offscreenCtx.stroke();
+        }
+        function drawWaveform() {
+            ctx.clearRect(0, 0, canvas.width, canvas.height);
+            ctx.drawImage(offscreenCanvas, 0, 0);
+            drawPlaybackLine();
+        }
+        function drawPlaybackLine() {
+            if (!audioBuffer || !audioSource) return;
+            const currentTime = audioContext.currentTime - startTime;
+            const canvasWidth = canvas.width;
+            const canvasHeight = canvas.height;
+            const duration = audioBuffer.duration;
+            const playbackPosition = (currentTime / duration) * canvasWidth;
+            ctx.beginPath();
+            ctx.moveTo(playbackPosition, 0);
+            ctx.lineTo(playbackPosition, canvasHeight);
+            ctx.strokeStyle = 'red';
+            ctx.stroke();
+        }
+        function playAudio() {
+            if (!audioBuffer) return;
+            stopAudio();
+            audioContext = new (window.AudioContext || window.webkitAudioContext)();
+            audioSource = audioContext.createBufferSource();
+            audioSource.buffer = audioBuffer;
+            audioSource.connect(audioContext.destination);
+            audioSource.onended = () => {
+                stopAudio();
+            };
+            startTime = audioContext.currentTime;
+            audioSource.start();
+            animatePlayback();
+        }
+        function stopAudio() {
+            if (audioSource) {
+                audioSource.stop();
+                audioSource = null;
+                cancelAnimationFrame(animationFrameId);
+                drawWaveform();
+            }
+        }
+        function seekAudio(event) {
+            if (!audioBuffer) return;
+            const clickX = event.offsetX;
+            const canvasWidth = canvas.width;
+            const duration = audioBuffer.duration;
+            const seekTime = (clickX / canvasWidth) * duration;
+            if (audioSource) {
+                audioSource.stop();
+            }
+            audioSource = audioContext.createBufferSource();
+            audioSource.buffer = audioBuffer;
+            audioSource.connect(audioContext.destination);
+            audioSource.onended = () => {
+                stopAudio();
+            };
+            audioSource.start(0, seekTime);
+            startTime = audioContext.currentTime - seekTime;
+            animatePlayback();
+        }
+        function animatePlayback() {
+            drawWaveform();
+            animationFrameId = requestAnimationFrame(animatePlayback);
+        }
+    </script>
+</body>
+</html>

NeuroPort/HTML+APPS/Калькулятор СВВ-50.HTML ADDED Viewed

	@@ -0,0 +1,176 @@

+<!DOCTYPE html>
+<html lang="ru">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Расчет гипсовой смеси</title>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            margin: 20px;
+        }
+        .container {
+            max-width: 400px;
+            margin: 0 auto;
+        }
+        label {
+            display: block;
+            margin-top: 10px;
+        }
+        input, select {
+            width: 100%;
+            padding: 8px;
+            margin-top: 5px;
+        }
+        button {
+            margin-top: 20px;
+            padding: 10px 20px;
+            background-color: #28a745;
+            color: white;
+            border: none;
+            cursor: pointer;
+        }
+        button:hover {
+            background-color: #218838;
+        }
+        .result {
+            margin-top: 20px;
+            padding: 10px;
+            background-color: #f8f9fa;
+            border: 1px solid #ddd;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>Расчет гипсовой смеси</h1>
+        <label for="volume">Объем формы (мл):</label>
+        <input type="number" id="volume" step="1" min="0" required>
+        <label for="plasticizerType">Тип пластификатора:</label>
+        <select id="plasticizerType">
+            <option value="classic">СВВ-500 Классик</option>
+            <option value="premium">СВВ-500 Premium</option>
+        </select>
+        <label for="plasticizerPercentage">Процент пластификатора:</label>
+        <select id="plasticizerPercentage">
+            <!-- Проценты для СВВ-500 Классик -->
+            <option value="1" data-type="classic">1%</option>
+            <option value="2" data-type="classic">2%</option>
+            <option value="3" data-type="classic">3%</option>
+            <option value="4" data-type="classic">4%</option>
+            <!-- Проценты для СВВ-500 Premium -->
+            <option value="0.3" data-type="premium">0.3%</option>
+            <option value="0.7" data-type="premium">0.7%</option>
+            <option value="1.2" data-type="premium">1.2%</option>
+            <option value="1.6" data-type="premium">1.6%</option>
+        </select>
+        <label for="dyePercentage">Процент красителя (0-5%):</label>
+        <input type="number" id="dyePercentage" min="0" max="5" value="0" required>
+        <button onclick="calculate()">Рассчитать</button>
+        <div class="result" id="result">
+            <h2>Результаты расчета:</h2>
+            <p>Гипс Г-16: <span id="gypsum"></span> г</p>
+            <p>Вода: <span id="water"></span> мл</p>
+            <p>Пластификатор: <span id="plasticizerAmount"></span> г</p>
+            <p>Краситель: <span id="dye"></span> г</p>
+        </div>
+    </div>
+    <script>
+        // Плотность гипса Г-16 (г/мл)
+        const gypsumDensity = 1.6; // 1.6 г/мл (1600 кг/м³)
+        // Базовое соотношение воды к гипсу (0.6 мл воды на 1 г гипса)
+        const baseWaterRatio = 0.6;
+        // Функция для обновления процентов пластификатора в зависимости от типа
+        function updatePlasticizerPercentages() {
+            const plasticizerType = document.getElementById('plasticizerType').value;
+            const percentageSelect = document.getElementById('plasticizerPercentage');
+            const options = percentageSelect.options;
+            for (let i = 0; i < options.length; i++) {
+                const option = options[i];
+                if (option.dataset.type === plasticizerType) {
+                    option.hidden = false;
+                } else {
+                    option.hidden = true;
+                }
+            }
+            // Устанавливаем первый доступный процент по умолчанию
+            percentageSelect.value = percentageSelect.querySelector('option:not([hidden])').value;
+        }
+        // Инициализация при загрузке страницы
+        document.getElementById('plasticizerType').addEventListener('change', updatePlasticizerPercentages);
+        updatePlasticizerPercentages();
+        // Основная функция расчета
+        function calculate() {
+            // Получаем данные из формы
+            const volume = parseFloat(document.getElementById('volume').value);
+            const plasticizerPercentage = parseFloat(document.getElementById('plasticizerPercentage').value);
+            const dyePercentage = parseFloat(document.getElementById('dyePercentage').value);
+            // Рассчитываем количество гипса
+            let gypsumAmount;
+            if (plasticizerPercentage === 1) {
+                gypsumAmount = volume * 1.37; // Коэффициент для 1%
+            } else if (plasticizerPercentage === 2) {
+                gypsumAmount = volume * 1.53; // Коэффициент для 2%
+            } else if (plasticizerPercentage === 3) {
+                gypsumAmount = volume * 1.63; // Коэффициент для 3%
+            } else if (plasticizerPercentage === 4) {
+                gypsumAmount = volume * 1.67; // Коэффициент для 4%
+            } else if (plasticizerPercentage === 0.3) {
+                gypsumAmount = volume * 1.33; // Коэффициент для 0.3%
+            } else if (plasticizerPercentage === 0.7) {
+                gypsumAmount = volume * 1.55; // Коэффициент для 0.7%
+            } else if (plasticizerPercentage === 1.2) {
+                gypsumAmount = volume * 1.6; // Коэффициент для 1.2%
+            } else if (plasticizerPercentage === 1.6) {
+                gypsumAmount = volume * 1.65; // Коэффициент для 1.6%
+            } else {
+                gypsumAmount = volume * gypsumDensity; // По умолчанию
+            }
+            // Рассчитываем количество воды
+            let waterAmount;
+            if (plasticizerPercentage === 1) {
+                waterAmount = gypsumAmount * 0.35; // Коэффициент для 1%
+            } else if (plasticizerPercentage === 2) {
+                waterAmount = gypsumAmount * 0.28; // Коэффициент для 2%
+            } else if (plasticizerPercentage === 3) {
+                waterAmount = gypsumAmount * 0.24; // Коэффициент для 3%
+            } else if (plasticizerPercentage === 4) {
+                waterAmount = gypsumAmount * 0.22; // Коэффициент для 4%
+            } else if (plasticizerPercentage === 0.3) {
+                waterAmount = gypsumAmount * 0.375; // Коэффициент для 0.3%
+            } else if (plasticizerPercentage === 0.7) {
+                waterAmount = gypsumAmount * 0.26; // Коэффициент для 0.7%
+            } else if (plasticizerPercentage === 1.2) {
+                waterAmount = gypsumAmount * 0.25; // Коэффициент для 1.2%
+            } else if (plasticizerPercentage === 1.6) {
+                waterAmount = gypsumAmount * 0.23; // Коэффициент для 1.6%
+            } else {
+                waterAmount = gypsumAmount * baseWaterRatio; // По умолчанию
+            }
+            // Рассчитываем количество пластификатора
+            const plasticizerAmount = (gypsumAmount * plasticizerPercentage) / 100;
+            // Рассчитываем количество красителя
+            const dyeAmount = (gypsumAmount * dyePercentage) / 100;
+            // Выводим результаты
+            document.getElementById('gypsum').textContent = gypsumAmount.toFixed(2);
+            document.getElementById('water').textContent = waterAmount.toFixed(2);
+            document.getElementById('plasticizerAmount').textContent = plasticizerAmount.toFixed(2);
+            document.getElementById('dye').textContent = dyeAmount.toFixed(2);
+        }
+    </script>
+</body>
+</html>