Skip to content
The Chat Archive
o4-mini-2025-04-16· OpenAI LMArena Human Preference 140K

напиши html js canvas симуляцию. 512*512 вид сверху. солнце греет поверхность. слои…

  1. User

    напиши html js canvas симуляцию. 512*512 вид сверху. солнце греет поверхность. слои воды, температуры, облаков. Вода испаряется, формируются облака, дожди. сделай одновременное отображение разных слоёв в разных canvas. физичность процесса. Оптимизация. Простая и расширяемая архитекрура, чтобы можно было добавить давление, ветер и др факторы в будущем.

  2. Assistant

    Ниже — минималистичный пример HTML+JS-симуляции “водно-теплового” цикла с испарением, образованием облаков и дождём.
    В нём:

    • Мультислойная архитектура: surface–water, vapor–water, clouds, temperature.
    • Симуляция в разрешении 128×128 (быстрее), рендерим на 512×512.
    • Все слои отображаются в своих canvas.
    • Процессы: испарение, конденсация, осадки, диффузия, нагрев от «солнца».
    • Лёгко расширять (например, добавить ветер, давление и т.п.).

    Скопируйте целиком в index.html и откройте в браузере:

    <!DOCTYPE html>
    <html lang="ru">
    <head>
      <meta charset="UTF-8">
      <title>Water–Cloud Cycle Simulation</title>
      <style>
        body { display: flex; flex-wrap: wrap; gap: 10px; font-family: sans-serif; }
        canvas { image-rendering: pixelated; border: 1px solid #aaa; }
        .layer { text-align: center; }
      </style>
    </head>
    <body>
      <div class="layer">
        <canvas id="c-water" width="512" height="512"></canvas><br>Water
      </div>
      <div class="layer">
        <canvas id="c-temp" width="512" height="512"></canvas><br>Temperature
      </div>
      <div class="layer">
        <canvas id="c-clouds" width="512" height="512"></canvas><br>Clouds
      </div>
    
      <script>
      // ==== Константы ====
      const SIM_RES = 128;          // разрешение симуляции
      const CANVAS_SIZE = 512;      // размер вывода
      const SCALE = CANVAS_SIZE / SIM_RES;
    
      const evapRate      = 0.002;  // коэффициент испарения
      const condThreshold = 0.02;   // порог конденсации
      const condRate      = 0.05;   // скорость конденсации
      const rainThreshold = 0.01;   // порог для осадков (облачная вода)
      const rainRate      = 0.1;    // скорость выпадения
      const heatRate      = 0.001;  // солнечный нагрев
      const diffRate      = 0.2;    // «диффузия» всех полей
    
      // ==== Утилиты ====
      function idx(x,y) { return (y*SIM_RES + x); }
      function clamp(v,lo,hi){ return v<lo?lo:(v>hi?hi:v); }
    
      // ==== Симуляция ====
      class Simulation {
        constructor(){
          const N = SIM_RES * SIM_RES;
          // Основные слои
          this.water   = new Float32Array(N); // surface water
          this.vapor   = new Float32Array(N); // water vapor
          this.cloud   = new Float32Array(N); // condensed water
          this.temp    = new Float32Array(N); // temperature [0..1]
          // Вспомогательные для диффузии
          this.vapor2  = new Float32Array(N);
          this.temp2   = new Float32Array(N);
    
          // Инициализируем
          for(let y=0;y<SIM_RES;y++){
            for(let x=0;x<SIM_RES;x++){
              const i = idx(x,y);
              this.water[i] = Math.random()*0.5 + 0.25; // отчасти влажно
              this.temp[i]  = 0.2 + 0.6*(y/SIM_RES);    // градиент «с юга на север»
            }
          }
        }
    
        step(){
          const W=this.water, V=this.vapor, C=this.cloud, T=this.temp;
          const V2=this.vapor2, T2=this.temp2;
    
          // 1) Испарение и конденсация/дождь
          for(let y=0;y<SIM_RES;y++){
            for(let x=0;x<SIM_RES;x++){
              let i = idx(x,y);
    
              // испарение ∝ вода * температура
              let evap = evapRate * W[i] * T[i];
              W[i] = clamp(W[i] - evap, 0, 1);
              V[i] = clamp(V[i] + evap, 0, 1);
    
              // конденсация облаков
              if(V[i] > condThreshold){
                let c = condRate * (V[i] - condThreshold);
                C[i] = clamp(C[i] + c, 0, 1);
                V[i] = clamp(V[i] - c, 0, 1);
              }
    
              // выпадение дождя
              if(C[i] > rainThreshold){
                let r = rainRate * (C[i] - rainThreshold);
                C[i] = clamp(C[i] - r, 0, 1);
                W[i] = clamp(W[i] + r, 0, 1);
              }
    
              // нагрев от солнца
              T[i] = clamp(T[i] + heatRate * (1 - T[i]), 0, 1);
            }
          }
    
          // 2) Диффузия (упрощённая): среднее с соседями
          for(let y=0;y<SIM_RES;y++){
            for(let x=0;x<SIM_RES;x++){
              let sumV=0, sumT=0, cnt=0;
              for(let oy=-1;oy<=1;oy++){
                for(let ox=-1;ox<=1;ox++){
                  let nx=x+ox, ny=y+oy;
                  if(nx>=0 && ny>=0 && nx<SIM_RES && ny<SIM_RES){
                    let j=idx(nx,ny);
                    sumV += V[j];
                    sumT += T[j];
                    cnt++;
                  }
                }
              }
              let i = idx(x,y);
              V2[i] = V[i] + diffRate*((sumV/cnt) - V[i]);
              T2[i] = T[i] + diffRate*((sumT/cnt) - T[i]);
            }
          }
          // swap буфферы
          this.vapor = V2.slice();
          this.temp  = T2.slice();
        }
      }
    
      // ==== Рендерер ====
      class Renderer {
        constructor(sim){
          this.sim = sim;
    
          // три canvas
          this.cW = document.getElementById('c-water');
          this.cT = document.getElementById('c-temp');
          this.cC = document.getElementById('c-clouds');
    
          this.ctxW = this.cW.getContext('2d');
          this.ctxT = this.cT.getContext('2d');
          this.ctxC = this.cC.getContext('2d');
    
          this.imgW = this.ctxW.createImageData(SIM_RES, SIM_RES);
          this.imgT = this.ctxT.createImageData(SIM_RES, SIM_RES);
          this.imgC = this.ctxC.createImageData(SIM_RES, SIM_RES);
        }
    
        render(){
          const {water, temp, cloud} = this.sim;
          this._drawLayer(water, this.imgW, colormapWater);
          this._drawLayer(temp,  this.imgT, colormapTemp);
          this._drawLayer(cloud,  this.imgC, colormapCloud);
    
          // scale up
          this.ctxW.putImageData(this.imgW, 0,0);
          this.ctxT.putImageData(this.imgT, 0,0);
          this.ctxC.putImageData(this.imgC, 0,0);
          [this.cW,this.cT,this.cC].forEach(c=> {
            this.ctxW.drawImage(c,0,0, SIM_RES,SIM_RES, 0,0,CANVAS_SIZE,CANVAS_SIZE);
          });
        }
    
        _drawLayer(buf, imgData, cmap){
          for(let i=0;i<buf.length;i++){
            let v = clamp(buf[i],0,1);
            let [r,g,b,a] = cmap(v);
            imgData.data[4*i  ] = r;
            imgData.data[4*i+1] = g;
            imgData.data[4*i+2] = b;
            imgData.data[4*i+3] = a;
          }
        }
      }
    
      // ==== Цветовые функции ====
      function colormapWater(v){
        // от бледно-голубого до насыщенного синего
        let r=0, g = 100 + v*155, b = 200 + v*55;
        return [r,g,b,255];
      }
      function colormapTemp(v){
        // холодно — синий, тепло — красный
        let r = v*255, g = 50, b = (1-v)*255;
        return [r,g,b,255];
      }
      function colormapCloud(v){
        // облака как полупрозрачные белые
        let alpha = v*255;
        return [255,255,255, alpha];
      }
    
      // ==== Основной цикл ====
      const sim = new Simulation();
      const rnd = new Renderer(sim);
    
      function loop(){
        sim.step();
        rnd.render();
        requestAnimationFrame(loop);
      }
      loop();
      </script>
    </body>
    </html>
    

    Как это работает и что дальше:

    1. Мы отделили модель (Simulation) от рендеринга (Renderer) ⇒ легко добавлять новые поля и процессы (ветер, давление, соленость и т.п.).
    2. Используем низкое разрешение 128×128 для расчётов и масштабируем до 512×512, чтобы было быстро.
    3. В каждом step() последовательно применяем физические правила, затем делаем простой «усредняющий» фильтр (диффузию).
    4. Рендерим три слоя в три canvas и масштабируем для отображения.

    Теперь вы можете:

    • Добавить новую артерию (например, this.pressure) в Simulation.
    • Написать процесс pressureDiffusion() или windAdvection().
    • Подключить их в step() и дать свои цветовые карты в Renderer.

    Удачных экспериментов! 🌦️

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