У меня есть браузерная игра, в которой пользователь может рисовать снежную горку с помощью мыши. После рисования пользователь нажимает кнопку "Старт", и на горку падают сани с человечком. Сани должны скользить по горке, учитывая при этом простую физику: они замедляются при подъеме в гору, ускоряются при спуске и подпрыгивают на неровностях. Вот код игры: 
<!DOCTYPE html>
<html lang="ru">
<head>
  <meta charset="UTF-8">
  <title>Снежная горка</title>
  <style>
    body {
      margin: 0;
      overflow: hidden;
      background: #87CEEB;
    }
    #distance {
      position: absolute;
      top: 10px;
      left: 10px;
      font-size: 24px;
      color: #fff;
      text-shadow: 1px 1px 2px #000;
    }
    #controls {
      position: absolute;
      top: 10px;
      right: 10px;
    }
    #controls button {
      padding: 10px 20px;
      font-size: 18px;
      margin-left: 10px;
    }
    button.active {
      background-color: #4CAF50;
      color: white;
    }
  </style>
</head>
<body>
  <canvas id="gameCanvas"></canvas>
  <div id="distance">Дистанция: 0 м</div>
  <div id="controls">
    <button id="startButton">Старт</button>
    <button id="resetButton">Новая горка</button>
    <button id="pencilButton" class="active">Карандаш</button>
    <button id="eraserButton">Ластик</button>
  </div>

  <script>
    const canvas = document.getElementById('gameCanvas');
    const ctx = canvas.getContext('2d');
    const distanceDisplay = document.getElementById('distance');
    const startButton = document.getElementById('startButton');
    const resetButton = document.getElementById('resetButton');
    const pencilButton = document.getElementById('pencilButton');
    const eraserButton = document.getElementById('eraserButton');

    canvas.width = window.innerWidth;
    canvas.height = window.innerHeight;

    let isDrawing = false;
    let isErasing = false;
    let hillSegments = [];
    let sled = null;
    let distanceTraveled = 0;
    let animationFrameId = null;
    let currentTool = 'pencil'; // По умолчанию выбран карандаш

    // Обновленный рисунок саней
    const sledImage = new Image();
    sledImage.src = 'data:image/svg+xml;base64,' + btoa(`
      <svg xmlns="http://www.w3.org/2000/svg" width="60" height="20">
        <path d="M5 15 L55 15 L50 10 L10 10 Z" fill="brown"/>
        <line x1="15" y1="15" x2="20" y2="5" stroke="brown" stroke-width="2"/>
        <line x1="45" y1="15" x2="40" y2="5" stroke="brown" stroke-width="2"/>
        <path d="M5 15 Q0 20 5 20 L55 20 Q60 15 55 15" fill="none" stroke="black" stroke-width="2"/>
      </svg>
    `);

    // Обновленный рисунок человечка с шапочкой
    const characterImage = new Image();
    characterImage.src = 'data:image/svg+xml;base64,' + btoa(`
      <svg xmlns="http://www.w3.org/2000/svg" width="20" height="40">
        <circle cx="10" cy="13" r="7" fill="pink"/>
        <polygon points="10,0 4,10 16,10" fill="red"/>
        <line x1="10" y1="20" x2="10" y2="35" stroke="black" stroke-width="2"/>
        <line x1="10" y1="25" x2="5" y2="30" stroke="black" stroke-width="2"/>
        <line x1="10" y1="25" x2="15" y2="30" stroke="black" stroke-width="2"/>
        <line x1="10" y1="35" x2="5" y2="40" stroke="black" stroke-width="2"/>
        <line x1="10" y1="35" x2="15" y2="40" stroke="black" stroke-width="2"/>
      </svg>
    `);

    // Обработка нажатий на кнопки "Карандаш" и "Ластик"
    pencilButton.addEventListener('click', () => {
      currentTool = 'pencil';
      pencilButton.classList.add('active');
      eraserButton.classList.remove('active');
    });

    eraserButton.addEventListener('click', () => {
      currentTool = 'eraser';
      eraserButton.classList.add('active');
      pencilButton.classList.remove('active');
    });

    // Рисование и стирание горки
    canvas.addEventListener('mousedown', (e) => {
      if (currentTool === 'pencil') {
        isDrawing = true;
        hillSegments.push([{ x: e.offsetX, y: e.offsetY }]);
      } else if (currentTool === 'eraser') {
        isErasing = true;
        eraseAt(e.offsetX, e.offsetY);
        draw();
      }
    });

    canvas.addEventListener('mousemove', (e) => {
      if (isDrawing && currentTool === 'pencil') {
        let currentSegment = hillSegments[hillSegments.length - 1];
        currentSegment.push({ x: e.offsetX, y: e.offsetY });
        draw();
      } else if (isErasing && currentTool === 'eraser') {
        eraseAt(e.offsetX, e.offsetY);
        draw();
      }
    });

    canvas.addEventListener('mouseup', () => {
      if (currentTool === 'pencil') {
        isDrawing = false;
        let currentSegment = hillSegments[hillSegments.length - 1];
        if (currentSegment.length >= 2) {
          currentSegment = smoothHill(currentSegment);
          hillSegments[hillSegments.length - 1] = currentSegment;
          draw();
        }
      } else if (currentTool === 'eraser') {
        isErasing = false;
      }
    });

    // Кнопка старта
    startButton.addEventListener('click', () => {
      if (hillSegments.length < 1) return;
      if (animationFrameId) {
        cancelAnimationFrame(animationFrameId);
        animationFrameId = null;
      }
      // Сбрасываем состояние саней и запускаем их заново
      sled = {
        x: hillSegments[0][0].x,
        y: hillSegments[0][0].y,
        vx: 0,
        vy: 0,
        segmentIndex: 0,
        pointIndex: 0,
        crashed: false,
        rotation: 0,
        angularVelocity: 0,
        character: {
          x: hillSegments[0][0].x,
          y: hillSegments[0][0].y - 20,
          vx: 0,
          vy: 0,
          inAir: false
        }
      };
      distanceTraveled = 0;
      distanceDisplay.textContent = 'Дистанция: 0 м';
      animate();
    });

    // Кнопка перезапуска
    resetButton.addEventListener('click', () => {
      if (animationFrameId) {
        cancelAnimationFrame(animationFrameId);
        animationFrameId = null;
      }
      hillSegments = [];
      sled = null;
      distanceTraveled = 0;
      distanceDisplay.textContent = 'Дистанция: 0 м';
      ctx.clearRect(0, 0, canvas.width, canvas.height);
    });

    // Функция сглаживания сегмента горки
    function smoothHill(points) {
      let smoothed = [];
      let windowSize = 5;
      for (let i = 0; i < points.length; i++) {
        let xSum = 0;
        let ySum = 0;
        let count = 0;
        for (let j = Math.max(0, i - Math.floor(windowSize / 2)); j <= Math.min(points.length - 1, i + Math.floor(windowSize / 2)); j++) {
          xSum += points[j].x;
          ySum += points[j].y;
          count++;
        }
        smoothed.push({ x: xSum / count, y: ySum / count });
      }
      return smoothed;
    }

    // Функция рисования горки
    function drawHill() {
      ctx.strokeStyle = '#fff';
      ctx.lineWidth = 5;
      for (let segment of hillSegments) {
        if (segment.length > 0) {
          ctx.beginPath();
          ctx.moveTo(segment[0].x, segment[0].y);
          for (let i = 1; i < segment.length; i++) {
            ctx.lineTo(segment[i].x, segment[i].y);
          }
          ctx.stroke();
        }
      }
    }

    // Функция рисования саней
    function drawSled() {
      ctx.save();
      ctx.translate(sled.x, sled.y);
      ctx.rotate(sled.rotation);
      ctx.drawImage(sledImage, -30, -10, 60, 20);
      ctx.restore();
    }

    // Функция рисования человечка
    function drawCharacter() {
      if (sled.character.inAir || sled.crashed) {
        ctx.save();
        ctx.translate(sled.character.x, sled.character.y);
        ctx.drawImage(characterImage, -10, -20, 20, 40);
        ctx.restore();
      } else {
        ctx.save();
        let segment = hillSegments[sled.segmentIndex];
        let p1 = segment[sled.pointIndex];
        let p2 = segment[sled.pointIndex + 1];
        let angle = Math.atan2(p2.y - p1.y, p2.x - p1.x);
        ctx.translate(sled.x, sled.y - 20);
        ctx.rotate(angle);
        ctx.drawImage(characterImage, -10, -20, 20, 40);
        ctx.restore();
      }
    }

    // Основная функция рисования
    function draw() {
      ctx.clearRect(0, 0, canvas.width, canvas.height);
      drawHill();
      if (sled) {
        drawSled();
        drawCharacter();
      }
    }

    // Проверка, находится ли объект на горке
    function isOnHill(x, y) {
      for (let s = 0; s < hillSegments.length; s++) {
        let segment = hillSegments[s];
        for (let i = 0; i < segment.length - 1; i++) {
          let p1 = segment[i];
          let p2 = segment[i + 1];
          if ((x >= p1.x && x <= p2.x) || (x >= p2.x && x <= p1.x)) {
            let t = (x - p1.x) / (p2.x - p1.x);
            let hillY = p1.y + t * (p2.y - p1.y);
            if (Math.abs(y - hillY) < 5) {
              return { onHill: true, hillY: hillY, segmentIndex: s, pointIndex: i };
            }
          }
        }
      }
      return { onHill: false, hillY: null };
    }

    // Анимация движения саней
    function animate() {
      if (!sled) return;

      let gravity = 0.5;
      let frictionCoefficient = 0.02;

      if (!sled.crashed) {
        let segment = hillSegments[sled.segmentIndex];

        if (sled.pointIndex >= segment.length - 1) {
          sled.segmentIndex++;
          sled.pointIndex = 0;
          if (sled.segmentIndex >= hillSegments.length) {
            alert('Игра окончена! Пройдена дистанция: ' + Math.floor(distanceTraveled / 10) + ' м');
            sled = null;
            return;
          }
          segment = hillSegments[sled.segmentIndex];
        }

        let p1 = segment[sled.pointIndex];
        let p2 = segment[sled.pointIndex + 1];
        let dx = p2.x - p1.x;
        let dy = p2.y - p1.y;
        let segmentLength = Math.sqrt(dx * dx + dy * dy);
        let tx = dx / segmentLength;
        let ty = dy / segmentLength;

        let v_parallel = sled.vx * tx + sled.vy * ty;

        let a_parallel = gravity * ty; // Компонента силы тяжести вдоль склона

        // Компонента силы трения
        let a_friction = -frictionCoefficient * gravity * Math.sign(v_parallel);

        v_parallel += a_parallel + a_friction;

        sled.vx = v_parallel * tx;
        sled.vy = v_parallel * ty;

        sled.x += sled.vx;
        sled.y += sled.vy;

        let hillCheck = isOnHill(sled.x, sled.y);
        if (!hillCheck.onHill) {
          sled.crashed = true;
          sled.angularVelocity = sled.vx * 0.05;
          sled.character.vx = sled.vx * 1.2;
          sled.character.vy = sled.vy - 5;
          sled.character.inAir = true;
        } else {
          sled.segmentIndex = hillCheck.segmentIndex;
          sled.pointIndex = hillCheck.pointIndex;
          sled.y = hillCheck.hillY; // Устанавливаем sled.y точно на линию горки
        }

        let speed = Math.sqrt(sled.vx * sled.vx + sled.vy * sled.vy);
        distanceTraveled += Math.abs(v_parallel);
        distanceDisplay.textContent = 'Дистанция: ' +
          Math.floor(distanceTraveled / 10) + ' м';

        if (speed > 35) {
          sled.crashed = true;
          sled.angularVelocity = sled.vx * 0.05;
          sled.character.vx = sled.vx * 1.2;
          sled.character.vy = sled.vy - 5;
          sled.character.inAir = true;
        }

        // Условие остановки игры при низкой скорости
        if (Math.abs(v_parallel) < 0.1) {
          alert('Сани остановились! Игра окончена. Пройдена дистанция: ' + Math.floor(distanceTraveled / 10) + ' м');
          sled = null;
          return;
        }
      } else {
        sled.angularVelocity += 0.001;
        sled.rotation += sled.angularVelocity;

        sled.vy += gravity;
        sled.x += sled.vx;
        sled.y += sled.vy;

        let hillCheckSled = isOnHill(sled.x, sled.y);
        if (hillCheckSled.onHill && sled.vy > 0) {
          sled.y = hillCheckSled.hillY;
          sled.vx *= 0.5;
          sled.vy = 0;
          sled.angularVelocity *= 0.5;
        }

        if (sled.character.inAir) {
          sled.character.vy += gravity;
          sled.character.x += sled.character.vx;
          sled.character.y += sled.character.vy;

          let hillCheckChar = isOnHill(sled.character.x, sled.character.y);
          if (hillCheckChar.onHill && sled.character.vy > 0) {
            sled.character.y = hillCheckChar.hillY;
            sled.character.vx *= 0.5;
            sled.character.vy = 0;
            sled.character.inAir = false;
          }
        }
      }

      if (sled.y > canvas.height && sled.character.y > canvas.height) {
        alert('Человечек упал! Игра окончена. Пройдена дистанция: ' + Math.floor(distanceTraveled / 10) + ' м');
        sled = null;
        return;
      }

      draw();
      animationFrameId = requestAnimationFrame(animate);
    }

    // Функция стирания части горки
    function eraseAt(x, y) {
      let eraseRadius = 20;

      for (let s = hillSegments.length - 1; s >= 0; s--) {
        let segment = hillSegments[s];
        let newSegments = [];
        let currentSegment = [];

        for (let i = 0; i < segment.length; i++) {
          let point = segment[i];
          let dx = point.x - x;
          let dy = point.y - y;
          let distance = Math.sqrt(dx * dx + dy * dy);

          if (distance >= eraseRadius) {
            currentSegment.push(point);
          } else {
            if (currentSegment.length >= 2) {
              newSegments.push(currentSegment);
            }
            currentSegment = [];
          }
        }
        if (currentSegment.length >= 2) {
          newSegments.push(currentSegment);
        }
        if (newSegments.length > 0) {
          hillSegments.splice(s, 1, ...newSegments);
        } else {
          hillSegments.splice(s, 1);
        }
      }
    }

    // Первоначальный вызов рисования
    draw();
  </script>
</body>
</html>

Нужно исправить несколько проблем. 
1. Сани находятся чуть ниже чем нарисована линия горки - это выглядит не красиво.
2. Если горка идет вверх и у саней не хватает инерции на неё заехать, то они откатываются назад, чтобы движение продолжалось до реальной остановки саней. Сейчас откат происходит, но максимум несколько раз, а надо чтобы они катались туда-сюда до полной остановки в нижней точке, если горка нарисована как впадина. 
3. При аварии саней сани падают в нужном месте, но человечек всегда вылетает с левого края экрана - он должен вылетать из саней и тормозить пузом по горке небольшое расстояние для эффекта. 
4. Если линия горки прерывается, но сразу происходит авария, а надо чтобы была возможность некоторого прыжка с трамплинов.
Помоги это поправить! Верни полный код исправленного файла html.