Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Mój kod wymaga ulepszenia: const canvas = document.getElementById("wordCanvas"); const…

  1. User

    Mój kod wymaga ulepszenia: const canvas = document.getElementById("wordCanvas"); const ctx = canvas.getContext("2d");

    function resizeCanvas() { const newWidth = parseInt(document.getElementById('widthInput').value, 10); const newHeight = parseInt(document.getElementById('heightInput').value, 10);

    if (newWidth > 0 && newHeight > 0) {
        canvasWidth = newWidth;
        canvasHeight = newHeight;
        canvas.width = canvasWidth;
        canvas.height = canvasHeight;
    
        // Aktualizuj rozmiar obszarĂłw
        const leftAreaWidth = canvasWidth / 2;
        const rightAreaWidth = canvasWidth / 2;
        const rightAreaX = canvasWidth / 2 + wordRadius;
    
        // Zaktualizuj położenie słów
        initializeGame(pairs);
    } else {
        alert('Wprowadź prawidłowe wartości szerokości i wysokości.');
    }
    

    }

    fetch('/user/get_synonim_data?game_name=Synonym Match') .then(response => response.json()) .then(data => { initializeGame(data[0].pairs); }) .catch(error => console.error('Błąd:', error));

    const canvasWidth = canvas.width; const canvasHeight = canvas.height; const wordRadius = 50; const leftAreaWidth = canvasWidth / 2; const rightAreaWidth = canvasWidth / 2; const leftAreaX = wordRadius; const rightAreaX = canvasWidth / 2 + wordRadius; const verticalSpacing = wordRadius * 1 + 10; // 20 to dodatkowa przestrzeń między słowami const leftMargin = 30; // Odległość słów od lewej krawędzi

    let words = []; let synonyms = []; let connections = []; let draggingLine = false; let startX = 0, startY = 0;
    let currentWord = null;

    function isOverlapping(word1, word2) { const dx = word1.x - word2.x; const dy = word1.y - word2.y; const distance = Math.sqrt(dx * dx + dy * dy); return distance < word1.radius + word2.radius; }

    function initializeGame(pairs) { // Pomieszaj kolejność par pairs = shuffleArray(pairs);

    pairs.forEach((pair, index) => {
        const wordY = verticalSpacing * index + wordRadius;
        if (wordY + wordRadius > canvasHeight) {
            console.error("Zbyt wiele par dla danego płótna.");
            return;
        }
    
        // Utwórz obiekt słowa z dodatkowym marginesem
        const word = {
            x: leftAreaX + leftMargin,
            y: wordY,
            radius: wordRadius,
            text: pair.word,
            pairIndex: index,
            color: "#FFD700"
        };
        words.push(word);
    
        // UtwĂłrz obiekt synonimu
        const synonym = {
            x: rightAreaX,
            y: wordY,
            radius: wordRadius,
            text: pair.synonym,
            pairIndex: index,
            color: "#ADFF2F"
        };
        synonyms.push(synonym);
    });
    drawWords();
    

    }

    function createNonOverlappingPosition(areaWidth, offset, text, index, color) { let position; let maxAttempts = 100; let attempts = 0;

    do {
        position = {
            x: Math.random() * (areaWidth - 2 * wordRadius) + offset + wordRadius,
            y: Math.random() * (canvasHeight - 2 * wordRadius) + wordRadius,
            radius: wordRadius,
            text: text,
            pairIndex: index,
            color: color
        };
        attempts++;
    } while (isOverlappingAny(position) && attempts < maxAttempts);
    
    return position;
    

    }

    // Funkcja pomocnicza do mieszania tablic function shuffleArray(array) { for (let i = array.length - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); [array[i], array[j]] = [array[j], array[i]]; } return array; }

    function isOverlappingAny(word) { return [...words, ...synonyms].some(existingWord => isOverlapping(word, existingWord)); }

    function drawConnectionPoints(word) { const radius = 5; // Radius of the connection point ctx.beginPath();

    if (words.includes(word)) { 
        // Draw point at the right edge of the word's rectangle
        const rectWidth = ctx.measureText(word.text).width + 20; // Width of the rectangle
        ctx.arc(word.x + rectWidth / 2, word.y, radius, 0, 2 * Math.PI);
    } else if (synonyms.includes(word)) {  
        // Draw point at the left edge of the synonym's rectangle
        const rectWidth = ctx.measureText(word.text).width + 20; // Width of the rectangle
        ctx.arc(word.x - rectWidth / 2, word.y, radius, 0, 2 * Math.PI);
    }
    
    ctx.fillStyle = "#FFF"; 
    ctx.fill();
    ctx.strokeStyle = "#000"; // Color of the border
    ctx.stroke();
    

    }

    function getConnectionPointAtPosition(x, y, wordList) { return wordList.find(word => { const rectWidth = ctx.measureText(word.text).width + 20; // Width of the rectangle if (words.includes(word)) { // Check if the point is near the right edge of the rectangle const dx = x - (word.x + rectWidth / 2); const dy = y - word.y; return Math.sqrt(dx * dx + dy * dy) < 5; } else if (synonyms.includes(word)) { // Check if the point is near the left edge of the rectangle const dx = x - (word.x - rectWidth / 2); const dy = y - word.y; return Math.sqrt(dx * dx + dy * dy) < 5; } }); }

    function drawWords() { ctx.clearRect(0, 0, canvasWidth, canvasHeight); // Clear the canvas

    // Draw connections
    connections.forEach(connection => {
        ctx.beginPath();
        const wordRectWidth = ctx.measureText(connection.word.text).width + 20;
        const synonymRectWidth = ctx.measureText(connection.synonym.text).width + 20;
        
        ctx.moveTo(connection.word.x + wordRectWidth / 2, connection.word.y);
        ctx.lineTo(connection.synonym.x - synonymRectWidth / 2, connection.synonym.y);
        
        ctx.strokeStyle = connection.correct ? "green" : "red";  // Color of the line
        ctx.lineWidth = 3;  
        ctx.stroke();
    
        // Draw cross in the middle of the line
        const midX = (connection.word.x + wordRectWidth / 2 + connection.synonym.x - synonymRectWidth / 2) / 2;
        const midY = (connection.word.y + connection.synonym.y) / 2;
        drawCross(midX, midY);
    });
    
    // Draw words and synonyms
    [...words, ...synonyms].forEach(word => {
        ctx.font = "16px Arial";
        const textWidth = ctx.measureText(word.text).width;
        const textHeight = 16; // Height of the font
    
        const margin = 10; // Margin in pixels
        const rectWidth = textWidth + 2 * margin;
        const rectHeight = textHeight + 2 * margin;
    
        let rectX, rectY;
        if (words.includes(word)) { 
            rectX = word.x - rectWidth / 2;
            rectY = word.y - rectHeight / 2;
        } else if (synonyms.includes(word)) {  
            rectX = word.x - rectWidth / 2;
            rectY = word.y - rectHeight / 2;
        }
    
        // Draw rectangle
        ctx.beginPath();
        ctx.rect(rectX, rectY, rectWidth, rectHeight);
        ctx.strokeStyle = word.color; // Border color
        ctx.lineWidth = 2; // Border width
        ctx.stroke();
    
        // Draw text
        ctx.fillStyle = "#000"; // Text color
        ctx.textAlign = "center";
        ctx.textBaseline = "middle";
        ctx.fillText(word.text, word.x, word.y);
    
        // Draw connection points
        drawConnectionPoints(word);
    });
    

    }

    function getWordAtPosition(x, y, wordList) { return wordList.find(word => { const dx = x - word.x; const dy = y - word.y; return Math.sqrt(dx * dx + dy * dy) < word.radius; }); }

    function drawCross(x, y, size = 10) { // Rysowanie białego kółka wokół krzyżyka const circleRadius = size * 0.75; // Ustal promień białego kółka ctx.beginPath(); ctx.arc(x, y, circleRadius, 0, 2 * Math.PI); ctx.fillStyle = "#FFF"; // Białe kółko ctx.fill(); ctx.strokeStyle = "#000"; // Czarny obrys kółka ctx.lineWidth = 1; ctx.stroke();

    // Rysowanie krzyĹĽyka
    ctx.beginPath();
    ctx.moveTo(x - size / 2, y - size / 2);
    ctx.lineTo(x + size / 2, y + size / 2);
    ctx.moveTo(x + size / 2, y - size / 2);
    ctx.lineTo(x - size / 2, y + size / 2);
    ctx.strokeStyle = "#FF0000";  // Czerwony krzyĹĽyk
    ctx.lineWidth = 2;
    ctx.stroke();
    

    }

    let selectedWord = null; let selectedSynonym = null;

    canvas.addEventListener("mousedown", (e) => { const mouseX = e.offsetX; const mouseY = e.offsetY;

    const clickedWord = getWordAtPosition(mouseX, mouseY, words);
    const clickedSynonym = getWordAtPosition(mouseX, mouseY, synonyms);
    
    if (clickedWord) {
        currentWord = clickedWord;
        startX = clickedWord.x;
        startY = clickedWord.y;
        draggingLine = true;
    } 
    else if (clickedSynonym) {
        currentWord = clickedSynonym;
        startX = clickedSynonym.x;
        startY = clickedSynonym.y;
        draggingLine = true;
    }
    

    });

    function makeConnection(word, synonym) { const existingConnection = connections.find(connection => connection.word === word || connection.synonym === synonym);

    if (existingConnection) {
        // Usuwamy istniejące połączenie, jeśli już istnieje
        connections = connections.filter(connection => connection !== existingConnection);
    }
    
    const correct = word.pairIndex === synonym.pairIndex;  // Sprawdzamy, czy połączenie jest prawidłowe
    
    connections.push({
        word: word,
        synonym: synonym,
        correct: correct
    });
    

    }

    canvas.addEventListener("mousemove", (e) => { if (draggingLine && currentWord) { const rect = canvas.getBoundingClientRect(); const scaleX = canvas.width / rect.width; const scaleY = canvas.height / rect.height;

        const mouseX = (e.clientX - rect.left) * scaleX;
        const mouseY = (e.clientY - rect.top) * scaleY;
    
        drawWords();  
    
        ctx.beginPath();
        
        if (words.includes(currentWord)) {
            ctx.moveTo(currentWord.x + currentWord.radius, currentWord.y);
        } else {
            ctx.moveTo(currentWord.x - currentWord.radius, currentWord.y);
        }
    
        ctx.lineTo(mouseX, mouseY);
        
        ctx.strokeStyle = "#000";  
        ctx.lineWidth = 2; 
        ctx.stroke();
    }
    

    });

    canvas.addEventListener("mouseup", (e) => { if (draggingLine && currentWord) { const mouseX = e.offsetX; const mouseY = e.offsetY;

        if (currentWord && currentWord.x < leftAreaWidth) {
            const targetSynonym = getWordAtPosition(mouseX, mouseY, synonyms);
            if (targetSynonym) {
                makeConnection(currentWord, targetSynonym);
            }
        } else {
            const targetWord = getWordAtPosition(mouseX, mouseY, words);
            if (targetWord) {
                makeConnection(targetWord, currentWord);
            }
        }
    
        draggingLine = false;
        currentWord = null;
        drawWords(); 
    }
    

    });

    canvas.addEventListener("mousedown", (e) => { const mouseX = e.offsetX; const mouseY = e.offsetY;

    const clickedConnection = connections.find(connection => isClickOnCross(mouseX, mouseY, connection));
    
    if (clickedConnection) {
        // Jeśli kliknięto krzyżyk, usuń połączenie
        connections = connections.filter(connection => connection !== clickedConnection);
        drawWords();
    } else {
        // Sprawdź, czy kliknięto na słowo lub synonim
        const clickedWord = getWordAtPosition(mouseX, mouseY, words);
        const clickedSynonym = getWordAtPosition(mouseX, mouseY, synonyms);
    
        if (clickedWord) {
            currentWord = clickedWord;
            startX = clickedWord.x;
            startY = clickedWord.y;
            draggingLine = true;
        } 
        else if (clickedSynonym) {
            currentWord = clickedSynonym;
            startX = clickedSynonym.x;
            startY = clickedSynonym.y;
            draggingLine = true;
        }
    }
    

    });

    canvas.addEventListener("mouseup", (e) => { if (draggingLine && currentWord) { const rect = canvas.getBoundingClientRect(); const scaleX = canvas.width / rect.width; const scaleY = canvas.height / rect.height;

        const mouseX = (e.clientX - rect.left) * scaleX;
        const mouseY = (e.clientY - rect.top) * scaleY;
    
        const targetWord = getConnectionPointAtPosition(mouseX, mouseY, words);
        const targetSynonym = getConnectionPointAtPosition(mouseX, mouseY, synonyms);
    
        if (targetWord && synonyms.includes(currentWord)) {
            makeConnection(targetWord, currentWord); // Połączenie od słowa do synonimu
        } else if (targetSynonym && words.includes(currentWord)) {
            makeConnection(currentWord, targetSynonym); // Połączenie od synonimu do słowa
        }
    
        draggingLine = false;
        currentWord = null;
        drawWords();  // Przerysuj wszystkie elementy
    }
    

    });

    function isClickOnCross(x, y, connection) { const wordRectWidth = ctx.measureText(connection.word.text).width + 20; const synonymRectWidth = ctx.measureText(connection.synonym.text).width + 20;

    // Zamiast dodawać stały promień, uwzględnij szerokość tekstu i wylicz miejsce na podstawie pozycji krawędzi prostokąta
    const midX = (connection.word.x + wordRectWidth / 2 + connection.synonym.x - synonymRectWidth / 2) / 2;
    const midY = (connection.word.y + connection.synonym.y) / 2;
    
    const dx = x - midX;
    const dy = y - midY;
    const distance = Math.sqrt(dx * dx + dy * dy);
    
    // Zwracamy true, jeśli kliknięto blisko krzyżyka (np. w promieniu 15px)
    return distance < 15;
    

    }

    canvas.addEventListener("click", (e) => { const rect = canvas.getBoundingClientRect(); const scaleX = canvas.width / rect.width; const scaleY = canvas.height / rect.height;

    const mouseX = (e.clientX - rect.left) * scaleX;
    const mouseY = (e.clientY - rect.top) * scaleY;
    
    const clickedConnection = connections.find(connection => isClickOnCross(mouseX, mouseY, connection));
    
    if (clickedConnection) {
        connections = connections.filter(connection => connection !== clickedConnection);
        drawWords();
    }
    

    });

    function pointLineDistance(px, py, x1, y1, x2, y2) { const A = px - x1; const B = py - y1; const C = x2 - x1; const D = y2 - y1;

    const dot = A * C + B * D;
    const len_sq = C * C + D * D;
    const param = (len_sq !== 0) ? (dot / len_sq) : -1;
    
    let xx, yy;
    
    if (param < 0) {
        xx = x1;
        yy = y1;
    } else if (param > 1) {
        xx = x2;
        yy = y2;
    } else {
        xx = x1 + param * C;
        yy = y1 + param * D;
    }
    
    const dx = px - xx;
    const dy = py - yy;
    return Math.sqrt(dx * dx + dy * dy);
    

    }

    function getConnectionAtPosition(x, y) { return connections.find(connection => { const distToLine = pointLineDistance(x, y, connection.word.x, connection.word.y, connection.synonym.x, connection.synonym.y); return distToLine < 5; }); }

  2. Assistant

    Twój kod zawiera kilka kwestii, które warto poprawić, aby działał bardziej efektywnie i był łatwiejszy w utrzymaniu. Poniżej przedstawiam sugestie ulepszeń wraz z wyjaśnieniami:

    1. Zduplikowane nasłuchiwanie zdarzenia "mousedown":

      W Twoim kodzie dwukrotnie dodajesz nasłuchiwanie zdarzenia "mousedown" dla elementu canvas. To powoduje, że oba funkcje obsługi zdarzenia są wywoływane przy każdym kliknięciu, co może prowadzić do nieoczekiwanych zachowań.

      Rozwiązanie: Połącz funkcjonalność obu obsługi zdarzeń w jedną funkcję lub usuń jedną z nich, jeśli jest zbędna.

      // Usuń jedno z poniższych nasłuchiwania lub połącz je w jedno
      canvas.addEventListener("mousedown", (e) => {
          // ... kod obsługi zdarzenia ...
      });
      
    2. Zmienne globalne i ich inicjalizacja:

      Niektóre zmienne są deklarowane po ich użyciu, co może prowadzić do błędów. Ponadto, używasz zarówno const, jak i let oraz deklarujesz zmienne globalne, co może być źródłem konfliktów i trudności w debugowaniu.

      Rozwiązanie:

      • Przenieś deklaracje zmiennych na początek skryptu.
      • Użyj let zamiast const dla zmiennych, których wartość będzie się zmieniać.
      • Unikaj deklarowania zmiennych globalnych bez potrzeby.
      let canvasWidth = canvas.width;
      let canvasHeight = canvas.height;
      // ... pozostałe zmienne ...
      
    3. Funkcja resizeCanvas():

      W funkcji resizeCanvas() próbujesz użyć zmiennej pairs, która może nie być dostępna w tym zasięgu (scope).

      Rozwiązanie:

      • Upewnij się, że zmienna pairs jest dostępna w tej funkcji. Możesz ją przekazać jako parametr lub zadeklarować jako zmienną globalną.
      • Przenieś lub zmodyfikuj kod tak, aby kolejność wykonania zapewniała dostępność tej zmiennej.
      function resizeCanvas() {
          // ... kod ...
          // Upewnij się, że 'pairs' jest dostępne tutaj
          initializeGame(pairs);
      }
      
    4. Użycie promienia (wordRadius) przy rysowaniu prostokątów:

      W kodzie używasz zmiennej wordRadius, ale rysujesz słowa w prostokątach, a nie w kołach. To może być mylące.

      Rozwiązanie:

      • Zmień nazwę zmiennej wordRadius na bardziej odpowiednią, np. wordHeight lub wordSpacing.
      • Upewnij się, że logika dotycząca pozycji i kolizji słów jest zgodna z rzeczywistymi kształtami (prostokąty zamiast kół).
      const wordHeight = 50; // Zamiast 'wordRadius'
      
    5. Funkcja initializeGame(pairs) i mieszanie par:

      W funkcji initializeGame() mieszasz tablicę pairs, co może prowadzić do niespójności przy sprawdzaniu poprawności połączeń, jeśli indeksy par są używane do weryfikacji.

      Rozwiązanie:

      • Jeśli mieszasz pairs, upewnij się, że odpowiednio aktualizujesz indeksy lub identyfikatory par, aby poprawne połączenia były wykrywane prawidłowo.
      • Rozważ dodanie unikalnego identyfikatora do każdej pary zamiast polegać na indeksach.
      pairs = pairs.map((pair, index) => ({ ...pair, id: index }));
      pairs = shuffleArray(pairs);
      
    6. Poprawa czytelności i organizacji kodu:

      • Uporządkuj kod, grupując powiązane funkcje i zmienne.
      • Dodaj komentarze wyjaśniające trudniejsze fragmenty kodu.
      • Rozważ podzielenie kodu na moduły lub klasy, jeśli jest to możliwe, aby zwiększyć jego modularność.
    7. Optymalizacja rysowania:

      • Zamiast rysować wszystko od nowa przy każdym ruchu myszy, możesz zoptymalizować rysowanie, odświeżając tylko potrzebne elementy.
      • Użyj metody requestAnimationFrame dla płynniejszego renderowania animacji.
    8. Obsługa zdarzeń dotykowych:

      Jeśli planujesz, aby gra działała na urządzeniach dotykowych, dodaj obsługę zdarzeń takich jak touchstart, touchmove, touchend.

    9. Walidacja danych z serwera:

      • Upewnij się, że dane pobierane z serwera są prawidłowe i obsłuż ewentualne błędy.
      • Dodaj obsługę sytuacji, gdy data jest puste lub ma nieoczekiwany format.
      fetch('/user/get_synonim_data?game_name=Synonym Match')
          .then(response => response.json())
          .then(data => {
              if (data && data[0] && data[0].pairs) {
                  initializeGame(data[0].pairs);
              } else {
                  console.error('Nieprawidłowe dane z serwera:', data);
              }
          })
          .catch(error => console.error('Błąd:', error));
      
    10. Refaktoryzacja funkcji kolizji:

      Funkcje takie jak isOverlapping i isOverlappingAny mogą być zoptymalizowane pod kątem wydajności, szczególnie jeśli liczba słów jest duża.

      Rozwiązanie:

      • Rozważ użycie bardziej efektywnych algorytmów lub struktur danych do wykrywania kolizji.
      • Możesz implementować siatkę przestrzenną lub inne techniki dzielenia przestrzeni.

    Poniżej przedstawiam zaktualizowany fragment Twojego kodu z uwzględnieniem niektórych powyższych sugestii:

    const canvas = document.getElementById("wordCanvas");
    const ctx = canvas.getContext("2d");
    
    let canvasWidth = canvas.width;
    let canvasHeight = canvas.height;
    const wordHeight = 50; // Zmiana nazwy zmiennej
    const leftAreaWidth = canvasWidth / 2;
    const rightAreaWidth = canvasWidth / 2;
    const leftAreaX = 30; // Margines od lewej krawędzi
    const rightAreaX = canvasWidth / 2 + 30;
    const verticalSpacing = wordHeight + 10;
    
    let words = [];
    let synonyms = [];
    let connections = [];
    let draggingLine = false;
    let currentWord = null;
    let pairs = [];
    
    function resizeCanvas() {
        const newWidth = parseInt(document.getElementById('widthInput').value, 10);
        const newHeight = parseInt(document.getElementById('heightInput').value, 10);
    
        if (newWidth > 0 && newHeight > 0) {
            canvasWidth = newWidth;
            canvasHeight = newHeight;
            canvas.width = canvasWidth;
            canvas.height = canvasHeight;
    
            // Aktualizuj rozmiar obszarów
            // ...
    
            // Zaktualizuj położenie słów
            initializeGame(pairs);
        } else {
            alert('Wprowadź prawidłowe wartości szerokości i wysokości.');
        }
    }
    
    fetch('/user/get_synonim_data?game_name=Synonym Match')
        .then(response => response.json())
        .then(data => {
            if (data && data[0] && data[0].pairs) {
                pairs = data[0].pairs;
                initializeGame(pairs);
            } else {
                console.error('Nieprawidłowe dane z serwera:', data);
            }
        })
        .catch(error => console.error('Błąd:', error));
    
    function initializeGame(pairsData) {
        words = [];
        synonyms = [];
        connections = [];
    
        pairsData = pairsData.map((pair, index) => ({ ...pair, id: index }));
        pairsData = shuffleArray(pairsData);
    
        pairsData.forEach((pair, index) => {
            const wordY = verticalSpacing * index + wordHeight;
            if (wordY + wordHeight > canvasHeight) {
                console.error("Zbyt wiele par dla danego płótna.");
                return;
            }
    
            const word = {
                x: leftAreaX,
                y: wordY,
                text: pair.word,
                id: pair.id,
                color: "#FFD700"
            };
            words.push(word);
    
            const synonym = {
                x: rightAreaX,
                y: wordY,
                text: pair.synonym,
                id: pair.id,
                color: "#ADFF2F"
            };
            synonyms.push(synonym);
        });
        drawWords();
    }
    
    // Połącz funkcje obsługi zdarzeń w jedną
    canvas.addEventListener("mousedown", (e) => {
        // ... kod obsługi kliknięcia myszą ...
    });
    
    // Upewnij się, że inne nasłuchiwania nie są zduplikowane
    

    Pamiętaj, że powyższy kod to tylko fragment i konieczne może być dostosowanie reszty kodu do wprowadzonych zmian.


    Jeśli masz dodatkowe pytania lub potrzebujesz pomocy w konkretnych częściach kodu, daj znać, a chętnie pomogę!