Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-11-20· OpenAIAi2 WildChat-4.8M (AI2)

import React, { useState, useEffect } from 'react'; import { MapContainer, TileLayer,…

  1. User

    import React, { useState, useEffect } from 'react'; import { MapContainer, TileLayer, GeoJSON, FeatureGroup } from 'react-leaflet'; import Button from '../Button/Button'; import { FaPause, FaPlay } from 'react-icons/fa';

    const MultipleChoiceMode = ({ kyrgyzstanRegions, setShowResults, setGameStarted, elapsedTime, setElapsedTime, isPaused, setIsPaused, togglePauseMenu, showPauseMenu, message, setMessage, navigate, setCorrectAnswers, setIncorrectAnswers }) => { const [regionData, setRegionData] = useState(null); const [guessedRegions, setGuessedRegions] = useState([]); const [remainingRegions, setRemainingRegions] = useState([]); const [totalRegions, setTotalRegions] = useState(0); const [currentRegion, setCurrentRegion] = useState(null); const [answerOptions, setAnswerOptions] = useState([]); const [incorrectGuesses, setIncorrectGuesses] = useState([]); const [correctAnswers, setCorrectAnswersLocal] = useState(0); const [incorrectAnswers, setIncorrectAnswersLocal] = useState(0); const [gameInitialized, setGameInitialized] = useState(false);

    const normalizeRegionName = (name) => { return name .toLowerCase() .trim() .replace(/[аáâãäå]/g, 'а') .replace(/[еéèêë]/g, 'е') .replace(/[иíìîï]/g, 'и') .replace(/[оóòôõö]/g, 'о') .replace(/[уúùûü]/g, 'у') .replace(/[ыýÿ]/g, 'ы') .replace(/[эèééêë]/g, 'э') .replace(/[юю]/g, 'ю') .replace(/[яя]/g, 'я'); };

    useEffect(() => { if (kyrgyzstanRegions) { setRegionData(kyrgyzstanRegions);

      const regionsList = kyrgyzstanRegions.features
        .map(feature => feature.properties.NAME_1)
        .filter(name => name !== undefined)
        .map(normalizeRegionName);
    
      setRemainingRegions(regionsList);
      setTotalRegions(regionsList.length);
      setGameInitialized(true);
    }
    

    }, [kyrgyzstanRegions]);

    useEffect(() => { let timer; if (!isPaused) { const startTime = Date.now() - (elapsedTime * 1000); timer = setInterval(() => { setElapsedTime(Math.floor((Date.now() - startTime) / 1000)); }, 1000); } return () => { if (timer) clearInterval(timer); }; }, [isPaused, elapsedTime]);

    const selectRandomRegion = () => { const availableRegions = remainingRegions.filter( region => !guessedRegions.includes(region) && !incorrectGuesses.includes(region) );

    if (availableRegions.length === 0) {
      setGameStarted(false);
      setShowResults(true);
      setCorrectAnswers(correctAnswers);
      setIncorrectAnswers(incorrectAnswers);
      return;
    }
    
    const randomIndex = Math.floor(Math.random() * availableRegions.length);
    const selectedRegion = availableRegions[randomIndex];
    setCurrentRegion(selectedRegion);
    
    const options = [selectedRegion];
    const potentialOptions = remainingRegions.filter(
      r => r !== selectedRegion &&
           !guessedRegions.includes(r) &&
           !incorrectGuesses.includes(r)
    );
    
    while (options.length < 4 && potentialOptions.length > 0) {
      const randomOptionIndex = Math.floor(Math.random() * potentialOptions.length);
      const randomOption = potentialOptions[randomOptionIndex];
    
      if (!options.includes(randomOption)) {
        options.push(randomOption);
        potentialOptions.splice(randomOptionIndex, 1);
      }
    }
    
    while (options.length < 4) {
      const randomOption = remainingRegions[Math.floor(Math.random() * remainingRegions.length)];
      if (!options.includes(randomOption)) {
        options.push(randomOption);
      }
    }
    
    setAnswerOptions(options.sort(() => Math.random() - 0.5));
    

    };

    const handleAnswerSelection = (selectedAnswer) => { if (selectedAnswer === currentRegion) { setCorrectAnswersLocal(prev => prev + 1); setMessage(Правильно! ${currentRegion}); setGuessedRegions(prev => [...prev, currentRegion]); } else { setIncorrectAnswersLocal(prev => prev + 1); setMessage(Неправильно. Правильный ответ: ${currentRegion}); setIncorrectGuesses(prev => [...prev, currentRegion]); }

    const unguessedRegions = remainingRegions.filter(
      r => !guessedRegions.includes(r) && !incorrectGuesses.includes(r)
    );
    
    if (unguessedRegions.length === 0) {
      setGameStarted(false);
      setShowResults(true);
      setCorrectAnswers(correctAnswers);
      setIncorrectAnswers(incorrectAnswers);
    } else {
      selectRandomRegion();
    }
    

    };

    const onEachRegion = (feature, layer) => { const regionName = feature.properties.NAME_1 ? normalizeRegionName(feature.properties.NAME_1) : '';

    const isGuessed = guessedRegions.includes(regionName);
    const isIncorrectGuess = incorrectGuesses.includes(regionName);
    
    layer.options.fillColor = isGuessed
      ? 'rgba(0, 255, 0, 0.5)'
      : isIncorrectGuess
      ? 'rgba(255, 0, 0, 0.5)'
      : 'transparent';
    
    layer.options.fillOpacity = isGuessed || isIncorrectGuess ? 0.7 : 0.2;
    layer.options.color = 'black';
    layer.options.weight = 1;
    
    if (isGuessed || isIncorrectGuess) {
      layer.bindTooltip(feature.properties.NAME_1, {
        permanent: true,
        direction: 'center',
        className: isGuessed ? 'correct-region-label' : 'incorrect-region-label'
      });
    }
    

    };

    useEffect(() => { if (gameInitialized && !currentRegion) { selectRandomRegion(); } }, [gameInitialized, currentRegion]);

    return ( <> <MapContainer center={[41.2044, 74.7661]} zoom={7} minZoom={5} maxZoom={15} style={{ height: '80vh', width: '100%' }} > {regionData && ( <GeoJSON key={guessedRegions.length + incorrectGuesses.length} data={regionData} onEachFeature={onEachRegion} /> )} {currentRegion && ( <GeoJSON data={regionData} style={{ fillColor: 'rgba(255, 0, 0, 0.5)', fillOpacity: 0.7, color: 'red', weight: 2, }} filter={(feature) => normalizeRegionName(feature.properties.NAME_1) === currentRegion} /> )}

      <div className="answer-options">
        <p>{message}</p>
        {answerOptions.map((option, index) => (
          <Button key={index} variant="primary" onClick={() => handleAnswerSelection(option)}>
            {option}
          </Button>
        ))}
      </div>
    
      <div className="small-stats-block">
        <p>Правильные ответы: {correctAnswers}</p>
        <p>Неправильные ответы: {incorrectAnswers}</p>
        <p>Процент правильных ответов: {((correctAnswers / (correctAnswers + incorrectAnswers)) * 100).toFixed(2)}%</p>
        <Button variant="secondary" onClick={togglePauseMenu}>
          {isPaused ? <FaPlay /> : <FaPause />}
        </Button>
      </div>
    
      {showPauseMenu && (
        <div className="pause-menu">
          <h2>Пауза</h2>
          <div className="guessed-regions-list">
            <h3>Угадано:</h3>
            <ul>
              {guessedRegions.map((name, index) => (
                <li key={index}>{name}</li>
              ))}
            </ul>
          </div>
          <p>Время: {elapsedTime} секунд</p>
          <Button variant="primary" onClick={() => navigate('/kyrgyzstan/games')}>Вернуться в меню выбора игры</Button>
          <Button variant="secondary" onClick={togglePauseMenu}>Продолжить игру</Button>
        </div>
      )}
    </>
    

    ); };

    export default MultipleChoiceMode;

    как понять по какой причине там повторяются уже отгаданные области

  2. Assistant

    Повторение уже отгаданных областей в этом коде может происходить из-за логики управления состояниями, которая некорректно обновляет список оставшихся областей или фильтрацию, которая не учитывает уже угаданные и неправильные ответы в selectRandomRegion. Вот разбор возможных причин и предложений, как можно исправить проблему:


    Основные проблемы:

    1. remainingRegions не обновляется корректно:

      • Вы используете remainingRegions, но нигде явно не удаляете угаданные или неправильные регионы из этого массива. Это может привести к тому, что угадывание или неверные ответы не обновляют состояние списка оставшихся регионов, которые могут быть выбраны снова.
    2. Фильтрация availableRegions неполная:

      • В функции selectRandomRegion вы фильтруете регионы через remainingRegions.filter(...), но неправильно проверяете состояния угаданных регионов и неправильных ответов.
    3. Возможное несоответствие setState с обновленным состоянием:

      • Обновление состояний, таких как guessedRegions и incorrectGuesses, асинхронно. В функции handleAnswerSelection может быть ситуация, где старое состояние используется до того, как setState обновит значение, что вызывает неожиданные результаты.

    Возможные решения:

    1. Корректно обновляйте remainingRegions: При каждом угаданном или неправильном ответе обновление списка оставшихся регионов должно явно удалять текущий регион:

      const handleAnswerSelection = (selectedAnswer) => {
          if (selectedAnswer === currentRegion) {
              setCorrectAnswersLocal(prev => prev + 1);
              setMessage(`Правильно! ${currentRegion}`);
              setGuessedRegions(prev => [...prev, currentRegion]);
          } else {
              setIncorrectAnswersLocal(prev => prev + 1);
              setMessage(`Неправильно. Правильный ответ: ${currentRegion}`);
              setIncorrectGuesses(prev => [...prev, currentRegion]);
          }
      
          setRemainingRegions(prev => prev.filter(region => region !== currentRegion));
          selectRandomRegion();
      };
      

      Это гарантирует, что угаданный регион немедленно удаляется из массива remainingRegions.


    1. Убедитесь, что фильтры в selectRandomRegion охватывают все регионы: Проверьте, чтобы доступные регионы корректно исключали уже угаданные (guessedRegions) и ошибочные ответы (incorrectGuesses):

      const selectRandomRegion = () => {
          const availableRegions = remainingRegions.filter(
              region => !guessedRegions.includes(region) && !incorrectGuesses.includes(region)
          );
      
          if (availableRegions.length === 0) {
              setGameStarted(false);
              setShowResults(true);
              setCorrectAnswers(correctAnswers);
              setIncorrectAnswers(incorrectAnswers);
              return;
          }
      
          const randomIndex = Math.floor(Math.random() * availableRegions.length);
          const selectedRegion = availableRegions[randomIndex];
          setCurrentRegion(selectedRegion);
      
          const options = [selectedRegion];
          const potentialOptions = remainingRegions.filter(
              r => r !== selectedRegion &&
                   !guessedRegions.includes(r) &&
                   !incorrectGuesses.includes(r)
          );
      
          while (options.length < 4 && potentialOptions.length > 0) {
              const randomOptionIndex = Math.floor(Math.random() * potentialOptions.length);
              const randomOption = potentialOptions[randomOptionIndex];
      
              if (!options.includes(randomOption)) {
                  options.push(randomOption);
                  potentialOptions.splice(randomOptionIndex, 1);
              }
          }
      
          while (options.length < 4) {
              const randomOption = remainingRegions[Math.floor(Math.random() * remainingRegions.length)];
              if (!options.includes(randomOption)) {
                  options.push(randomOption);
              }
          }
      
          setAnswerOptions(options.sort(() => Math.random() - 0.5));
      };
      

    1. Используйте useEffect для синхронизации состояний: Если вы предпочитаете не обновлять remainingRegions напрямую в handleAnswerSelection, используйте useEffect для автоматического синхронного удаления угаданных и неправильных регионов:

      useEffect(() => {
          const unguessedRegions = kyrgyzstanRegions.features
              .map(feature => normalizeRegionName(feature.properties.NAME_1))
              .filter(region =>
                  !guessedRegions.includes(region) && !incorrectGuesses.includes(region)
              );
      
          setRemainingRegions(unguessedRegions);
      }, [guessedRegions, incorrectGuesses]);
      

      Это автоматически пересчитывает remainingRegions при добавлении новых регионов в guessedRegions или incorrectGuesses.


    1. Проверяйте завершённость игры: Если список доступных регионов пуст, игра должна завершаться:

      useEffect(() => {
          if (remainingRegions.length === 0) {
              setGameStarted(false);
              setShowResults(true);
              setCorrectAnswers(correctAnswers);
              setIncorrectAnswers(incorrectAnswers);
          }
      }, [remainingRegions, correctAnswers, incorrectAnswers]);
      

      Этот useEffect гарантирует, что игра завершится, когда больше нет доступных регионов.


    Итог:

    Чтобы избежать повторения уже угаданных областей:

    • Корректно изменяйте remainingRegions при каждом шаге.
    • Фильтруйте доступные регионы с учётом всех угаданных и ошибочных ответов.
    • Проверьте использование асинхронных setState, чтобы избежать состояния гонки.
    • Убедитесь, что игра завершится, когда оставшихся регионов больше нет.

    Эти шаги должны устранить проблему повтора регионов.