Click here for free DL of the app version that can save data.

No:41338

Create a word search with the words love dream fai..ALL
Developer User18512｜Date and time 24/2/7 0:21:18
Build time 24.409 sec｜Game capacity 5.88KB｜

Script

Sure! Here's an example of a word search game using HTML and JavaScript that meets your requirements:

Word Search Game

This code will create a word search grid with the words "love," "dream," and "faith" hidden in random directions. You can click on the cells to highlight and mark the words as you find them. Once all the words have been found, an alert will congratulate you on completing the game.

←

Prev　Next

→ 　

Back　

[PR]現在の売れ筋アプリランキング

Click here for free DL of the app version that can save data.

Sure! Here's an example of a word search game using HTML and JavaScript that meets your requirements:

```html
<!DOCTYPE html>
<html>
<head>
    <title>Word Search Game</title>
    <style>
        /* CSS for styling the word search grid */
        table {
            border-collapse: collapse;
            margin: auto;
        }
        
        td {
            width: 30px;
            height: 30px;
            border: 1px solid #ddd;
            text-align: center;
        }
    </style>
</head>
<body>
    <h1>Word Search Game</h1>
    <table id="wordSearchGrid"></table>

// Function to create the word search grid
        function createWordSearchGrid(size) {
            const grid = [];
            for (let i = 0; i < size; i++) {
                const row = [];
                for (let j = 0; j < size; j++) {
                    const randomChar = String.fromCharCode(65 + Math.floor(Math.random() * 26));
                    row.push(randomChar);
                }
                grid.push(row);
            }
            return grid;
        }

// Function to check if all words are found
        function checkGameCompletion() {
            for (const word of words) {
                if (!word.found) {
                    return false;
                }
            }
            return true;
        }

// Function to highlight and mark found words
        function selectWord(row, col, direction, length) {
            const word = words.find(word => word.row === row && word.col === col && word.direction === direction && word.length === length);
            if (word) {
                for (let i = 0; i < length; i++) {
                    const cell = document.getElementById(`cell-${row + (i * word.dy)}-${col + (i * word.dx)}`);
                    cell.style.backgroundColor = "yellow";
                }
                word.found = true;
            }
        }

// Event listener for cell clicks
        function cellClick(event) {
            const cellId = event.target.id.split("-");
            const row = parseInt(cellId[1]);
            const col = parseInt(cellId[2]);

for (const word of words) {
                const dx = [0, 1, 1, 1, 0, -1, -1, -1];
                const dy = [-1, -1, 0, 1, 1, 1, 0, -1];

for (let direction = 0; direction < 8; direction++) {
                    let length = 1;
                    let found = false;

while (!found) {
                        const newRow = row + (length * dy[direction]);
                        const newCol = col + (length * dx[direction]);

if (newRow < 0 || newRow >= gridSize || newCol < 0 || newCol >= gridSize) {
                            break;
                        }

if (grid[newRow][newCol] === word[word.length - length]) {
                            if (length === word.length - 1) {
                                selectWord(row, col, direction, word.length);
                                if (checkGameCompletion()) {
                                    alert("Congratulations! You found all words.");
                                }
                                return;
                            }
                            length++;
                        } else {
                            break;
                        }
                    }
                }
            }
        }

// Function to render the word search grid
        function renderGrid() {
            const table = document.getElementById("wordSearchGrid");
            table.innerHTML = "";

for (let row = 0; row < gridSize; row++) {
                const tr = document.createElement("tr");
                for (let col = 0; col < gridSize; col++) {
                    const td = document.createElement("td");
                    td.id = `cell-${row}-${col}`;
                    td.innerText = grid[row][col];
                    td.addEventListener("click", cellClick);
                    tr.appendChild(td);
                }
                table.appendChild(tr);
            }
        }

// Function to initialize the word positions
        function initWords() {
            for (const word of words) {
                const direction = Math.floor(Math.random() * 8);
                let dx = [0, 1, 1, 1, 0, -1, -1, -1][direction];
                let dy = [-1, -1, 0, 1, 1, 1, 0, -1][direction];

const startRow = Math.floor(Math.random() * gridSize);
                const startCol = Math.floor(Math.random() * gridSize);
                let endRow = startRow + ((word.length - 1) * dy);
                let endCol = startCol + ((word.length - 1) * dx);

if (endRow < 0 || endRow >= gridSize || endCol < 0 || endCol >= gridSize) {
                    dx *= -1;
                    dy *= -1;
                    endRow = startRow + ((word.length - 1) * dy);
                    endCol = startCol + ((word.length - 1) * dx);
                }

word.row = startRow;
                word.col = startCol;
                word.direction = direction;
                word.found = false;
                word.dx = dx;
                word.dy = dy;
            }
        }

// Initialize the game
        initWords();
        renderGrid();
    </script>
</body>
</html>
```