Mój kod wymaga ulepszenia: const canvas = document.getElementById("wordCanvas"); const…
- 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; }); }
- 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:
-
Zduplikowane nasłuchiwanie zdarzenia "mousedown":
W Twoim kodzie dwukrotnie dodajesz nasłuchiwanie zdarzenia
"mousedown"dla elementucanvas. 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 ... }); -
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 iletoraz 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
letzamiastconstdla 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 ... -
Funkcja
resizeCanvas():W funkcji
resizeCanvas()próbujesz użyć zmiennejpairs, która może nie być dostępna w tym zasięgu (scope).Rozwiązanie:
- Upewnij się, że zmienna
pairsjest 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); } - Upewnij się, że zmienna
-
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
wordRadiusna bardziej odpowiednią, np.wordHeightlubwordSpacing. - 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' - Zmień nazwę zmiennej
-
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); - Jeśli mieszasz
-
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ść.
-
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
requestAnimationFramedla płynniejszego renderowania animacji.
-
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. -
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
datajest 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)); -
Refaktoryzacja funkcji kolizji:
Funkcje takie jak
isOverlappingiisOverlappingAnymogą 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ą zduplikowanePamię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ę!
-