@windward/games 0.0.4 → 0.0.6

package/components/content/DatableEditor.vue

@@ -170,8 +170,6 @@ export default {
             const item = evt.draggedContext.element
             const itemIdx = evt.draggedContext.futureIndex
 
-            console.log('onMoveCallback', evt)
-
             if (item.locked) {
                 return false
             }
@@ -179,7 +177,6 @@ export default {
             return true
         },
         onDropCallback(evt, originalEvent) {
-            console.log('onDropCallback')
             this.$emit('input', this.items)
         },
         editItem(item) {

package/components/content/blocks/crosswordPuzzle/Crossword.ts

@@ -9,163 +9,172 @@ class Crossword {
     // This is an index of the positions of the char in the crossword (so we know where we can potentially place words)
     // example {"a" : [{'row' : 10, 'col' : 5}, {'row' : 62, 'col' :17}], {'row' : 54, 'col' : 12}], "b" : [{'row' : 3, 'col' : 13}]}
     // where the two item arrays are the row and column of where the letter occurs
-    public char_index!: {}
+    public charIndex: any = {}
     // these words are the words that can't be placed on the crossword
-    public bad_words!: any
-    public words_in!: any
-    public clues_in!: any
+    public badWords!: any
+    public wordsIn!: any
+    public cluesIn!: any
     public grid: any = []
-    public word_elements: any = []
-    constructor(words_in, clues_in) {
-        this.words_in = words_in
-        this.clues_in = clues_in
+    public wordElements: any = []
+
+    constructor(wordsIn: any, cluesIn: any) {
+        this.wordsIn = wordsIn
+        this.cluesIn = cluesIn
         // constructor
-        if (this.words_in.length < 2)
+        if (this.wordsIn.length < 2)
             throw 'A crossword must have at least 2 words'
-        if (this.words_in.length != clues_in.length)
+        if (this.wordsIn.length !== cluesIn.length)
             throw 'The number of words must equal the number of clues'
         // build the grid;
         this.grid = new Array(this.GRID_ROWS)
-        for (var i = 0; i < this.GRID_ROWS; i++) {
+        for (let i = 0; i < this.GRID_ROWS; i++) {
             this.grid[i] = new Array(this.GRID_COLS)
         }
 
         // build the element list (need to keep track of indexes in the originial input arrays)
-        for (let i = 0; i < words_in.length; i++) {
-            this.word_elements.push(new WordElement(words_in[i], i))
+        for (let i = 0; i < wordsIn.length; i++) {
+            this.wordElements.push(new WordElement(wordsIn[i], i))
         }
 
         // I got this sorting idea from http://stackoverflow.com/questions/943113/algorithm-to-generate-a-crossword/1021800#1021800
         // seems to work well
-        this.word_elements.sort(function (a, b) {
+        this.wordElements.sort(function (a: any, b: any) {
             return b.word.length - a.word.length
         })
     }
 
     // returns the crossword grid that has the ratio closest to 1 or null if it can't build one
-    public getSquareGrid(max_tries) {
-        let best_grid: any = null
-        var best_ratio = 0
-        for (var i = 0; i < max_tries; i++) {
-            var a_grid = this.getGrid(1)
-            if (a_grid == null) {
+    public getSquareGrid(maxTries: number) {
+        let bestGrid: any = null
+        let bestRatio = 0
+        for (let i = 0; i < maxTries; i++) {
+            let aGrid: any = this.getGrid(1)
+            if (aGrid === null) {
                 continue
             }
-            var ratio =
-                (Math.min(a_grid.length, a_grid[0].length) * 1.0) /
-                Math.max(a_grid.length, a_grid[0].length)
-            if (ratio > best_ratio) {
-                best_grid = a_grid
-                best_ratio = ratio
+            let ratio =
+                (Math.min(aGrid.length, aGrid[0].length) * 1.0) /
+                Math.max(aGrid.length, aGrid[0].length)
+            if (ratio > bestRatio) {
+                bestGrid = aGrid
+                bestRatio = ratio
             }
 
-            if (best_ratio == 1) break
+            if (bestRatio === 1) break
         }
-        return best_grid
+        return bestGrid
     }
 
     // returns an abitrary grid, or null if it can't build one
-    public getGrid(max_tries) {
-        for (var tries = 0; tries < max_tries; tries++) {
-            this.clear() // always start with a fresh grid and char_index
+    public getGrid(maxTries: number) {
+        const groups: any = []
+        let wordHasBeenAddedToGrid: boolean = false
+
+        for (let tries = 0; tries < maxTries; tries++) {
+            this.clear() // always start with a fresh grid and charIndex
             // place the first word in the middle of the grid
-            var start_dir = this.randomDirection()
-            var r = Math.floor(this.grid.length / 2)
-            var c = Math.floor(this.grid[0].length / 2)
+            let start_dir = this.randomDirection()
+            let r = Math.floor(this.grid.length / 2)
+            let c = Math.floor(this.grid[0].length / 2)
 
-            var word_element = this.word_elements[0]
-            if (start_dir == 'across') {
-                c -= Math.floor(word_element.word.length / 2)
+            let wordElement = this.wordElements[0]
+            if (start_dir === 'across') {
+                c -= Math.floor(wordElement.word.length / 2)
             } else {
-                r -= Math.floor(word_element.word.length / 2)
+                r -= Math.floor(wordElement.word.length / 2)
             }
 
             if (
-                this.canPlaceWordAt(word_element.word, r, c, start_dir) !==
-                false
+                this.canPlaceWordAt(wordElement.word, r, c, start_dir) !== false
             ) {
                 this.placeWordAt(
-                    word_element.word,
-                    word_element.index,
+                    wordElement.word,
+                    wordElement.index,
                     r,
                     c,
                     start_dir
                 )
             } else {
-                this.bad_words = [word_element]
+                this.badWords = [wordElement]
                 return null
             }
 
             // start with a group containing all the words (except the first)
             // as we go, we try to place each word in the group onto the grid
             // if the word can't go on the grid, we add that word to the next group
-            var groups: any = []
-            let word_has_been_added_to_grid
-            groups.push(this.word_elements.slice(1))
-            for (var g = 0; g < groups.length; g++) {
-                word_has_been_added_to_grid = false
+
+            groups.push(this.wordElements.slice(1))
+            for (let g = 0; g < groups.length; g++) {
+                wordHasBeenAddedToGrid = false
                 // try to add all the words in this group to the grid
-                for (var i = 0; i < groups[g].length; i++) {
-                    word_element = groups[g][i]
-                    var best_position = this.findPositionForWord(
-                        word_element.word
+                for (let i = 0; i < groups[g].length; i++) {
+                    wordElement = groups[g][i]
+                    const bestPosition: any = this.findPositionForWord(
+                        wordElement.word
                     )
-                    if (!best_position) {
+                    if (!bestPosition) {
                         // make the new group (if needed)
-                        if (groups.length - 1 == g) groups.push([])
+                        if (groups.length - 1 === g) groups.push([])
                         // place the word in the next group
-                        groups[g + 1].push(word_element)
+                        groups[g + 1].push(wordElement)
                     } else {
-                        ;(r = best_position['row']), (c = best_position['col'])
-                        var dir = best_position['direction']
+                        r = bestPosition['row']
+                        c = bestPosition['col']
+
                         this.placeWordAt(
-                            word_element.word,
-                            word_element.index,
+                            wordElement.word,
+                            wordElement.index,
                             r,
                             c,
-                            dir
+                            bestPosition['direction']
                         )
-                        word_has_been_added_to_grid = true
+                        wordHasBeenAddedToGrid = true
                     }
                 }
                 // if we haven't made any progress, there is no point in going on to the next group
-                if (!word_has_been_added_to_grid) break
+                if (!wordHasBeenAddedToGrid) break
             }
             // no need to try again
-            if (word_has_been_added_to_grid) return this.minimizeGrid()
+            if (wordHasBeenAddedToGrid) return this.minimizeGrid()
         }
 
-        this.bad_words = groups[groups.length - 1]
+        this.badWords = groups[groups.length - 1]
         return null
     }
 
     // returns the list of WordElements that can't fit on the crossword
     public getBadWords() {
-        return this.bad_words
+        return this.badWords
     }
 
     // get two arrays ("across" and "down") that contain objects describing the
     // topological position of the word (e.g. 1 is the first word starting from
     // the top left, going to the bottom right), the index of the word (in the
     // original input list), the clue, and the word itself
-    public getLegend(grid) {
-        var groups = { across: [], down: [] }
-        var position = 1
-        for (var r = 0; r < grid.length; r++) {
-            for (var c = 0; c < grid[r].length; c++) {
-                var cell = grid[r][c]
-                var increment_position = false
+    public getLegend(grid: any) {
+        let groups: any = { across: [], down: [] }
+        let position = 1
+        for (let row = 0; row < grid.length; row++) {
+            for (let col = 0; col < grid[row].length; col++) {
+                let cell = grid[row][col]
+                let increment_position = false
                 // check across and down
-                for (var k in groups) {
+                for (let direction in groups) {
                     // does a word start here? (make sure the cell isn't null, first)
-                    if (cell && cell[k] && cell[k]['is_start_of_word']) {
-                        var index = cell[k]['index']
-                        groups[k].push({
+                    if (
+                        cell &&
+                        cell[direction] &&
+                        cell[direction].isStartOfWord
+                    ) {
+                        const index = cell[direction].index
+                        groups[direction].push({
                             position: position,
                             index: index,
-                            clue: this.clues_in[index],
-                            word: this.words_in[index],
+                            clue: this.cluesIn[index],
+                            word: this.wordsIn[index],
                         })
+                        // Set the cell position now that we've generated a legend
+                        cell[direction].position = position
                         increment_position = true
                     }
                 }
@@ -179,14 +188,15 @@ class Crossword {
     // move the grid onto the smallest grid that will fit it
     public minimizeGrid() {
         // find bounds
-        var r_min = this.GRID_ROWS - 1,
-            r_max = 0,
-            c_min = this.GRID_COLS - 1,
-            c_max = 0
-        for (var r = 0; r < this.GRID_ROWS; r++) {
-            for (var c = 0; c < this.GRID_COLS; c++) {
-                var cell = this.grid[r][c]
-                if (cell != null) {
+        let r_min = this.GRID_ROWS - 1
+        let r_max = 0
+        let c_min = this.GRID_COLS - 1
+        let c_max = 0
+
+        for (let r = 0; r < this.GRID_ROWS; r++) {
+            for (let c = 0; c < this.GRID_COLS; c++) {
+                let cell = this.grid[r][c]
+                if (cell !== null) {
                     if (r < r_min) r_min = r
                     if (r > r_max) r_max = r
                     if (c < c_min) c_min = c
@@ -195,9 +205,9 @@ class Crossword {
             }
         }
         // initialize new grid
-        var rows = r_max - r_min + 1
-        var cols = c_max - c_min + 1
-        var new_grid = new Array(rows)
+        let rows = r_max - r_min + 1
+        let cols = c_max - c_min + 1
+        let new_grid = new Array(rows)
         for (let r = 0; r < rows; r++) {
             for (let c = 0; c < cols; c++) {
                 new_grid[r] = new Array(cols)
@@ -216,50 +226,55 @@ class Crossword {
 
     // helper for placeWordAt();
     public addCellToGrid(
-        word,
-        index_of_word_in_input_list,
-        index_of_char,
-        r,
-        c,
-        direction
+        word: any,
+        indexOfWordInInputList: any,
+        indexOfChar: any,
+        row: any,
+        col: any,
+        direction: any
     ) {
-        var char = word.charAt(index_of_char)
-        if (this.grid[r][c] == null) {
-            this.grid[r][c] = new CrosswordCell(char)
+        const char = word.charAt(indexOfChar)
+        if (this.grid[row][col] === null) {
+            this.grid[row][col] = new CrosswordCell(char)
 
-            // init the char_index for that character if needed
-            if (!this.char_index[char]) this.char_index[char] = []
+            // init the charIndex for that character if needed
+            if (!this.charIndex[char]) this.charIndex[char] = []
 
             // add to index
-            this.char_index[char].push({ row: r, col: c })
+            this.charIndex[char].push({ row, col })
         }
 
-        var is_start_of_word = index_of_char == 0
-        this.grid[r][c][direction] = new CrosswordCellNode(
-            is_start_of_word,
-            index_of_word_in_input_list
+        this.grid[row][col][direction] = new CrosswordCellNode(
+            indexOfChar === 0,
+            indexOfWordInInputList
         )
     }
 
     // place the word at the row and col indicated (the first char goes there)
     // the next chars go to the right (across) or below (down), depending on the direction
-    public placeWordAt(word, index_of_word_in_input_list, row, col, direction) {
-        if (direction == 'across') {
+    public placeWordAt(
+        word: any,
+        indexOfWordInInputList: any,
+        row: any,
+        col: any,
+        direction: any
+    ) {
+        if (direction === 'across') {
             for (let c = col, i = 0; c < col + word.length; c++, i++) {
                 this.addCellToGrid(
                     word,
-                    index_of_word_in_input_list,
+                    indexOfWordInInputList,
                     i,
                     row,
                     c,
                     direction
                 )
             }
-        } else if (direction == 'down') {
+        } else if (direction === 'down') {
             for (let r = row, i = 0; r < row + word.length; r++, i++) {
                 this.addCellToGrid(
                     word,
-                    index_of_word_in_input_list,
+                    indexOfWordInInputList,
                     i,
                     r,
                     col,
@@ -276,17 +291,17 @@ class Crossword {
     // returns false, if you can't place the char
     // 0 if you can place the char, but there is no intersection
     // 1 if you can place the char, and there is an intersection
-    public canPlaceCharAt(char, row, col) {
+    public canPlaceCharAt(char: any, row: any, col: any) {
         // no intersection
-        if (this.grid[row][col] == null) return 0
+        if (this.grid[row][col] === null) return 0
         // intersection!
-        if (this.grid[row][col]['char'] == char) return 1
+        if (this.grid[row][col]['char'] === char) return 1
 
         return false
     }
 
     // determines if you can place a word at the row, column in the direction
-    public canPlaceWordAt(word, row, col, direction): any {
+    public canPlaceWordAt(word: any, row: any, col: any, direction: any): any {
         // out of bounds
         if (
             row < 0 ||
@@ -296,17 +311,17 @@ class Crossword {
         )
             return false
 
-        var intersections
+        let intersections
 
-        if (direction == 'across') {
+        if (direction === 'across') {
             // out of bounds (word too long)
             if (col + word.length > this.grid[row].length) return false
             // can't have a word directly to the left
-            if (col - 1 >= 0 && this.grid[row][col - 1] != null) return false
+            if (col - 1 >= 0 && this.grid[row][col - 1] !== null) return false
             // can't have word directly to the right
             if (
                 col + word.length < this.grid[row].length &&
-                this.grid[row][col + word.length] != null
+                this.grid[row][col + word.length] !== null
             )
                 return false
 
@@ -318,10 +333,10 @@ class Crossword {
                 r >= 0 && c < col + word.length;
                 c++, i++
             ) {
-                let is_empty = this.grid[r][c] == null
+                let is_empty = this.grid[r][c] === null
                 let is_intersection =
-                    this.grid[row][c] != null &&
-                    this.grid[row][c]['char'] == word.charAt(i)
+                    this.grid[row][c] !== null &&
+                    this.grid[row][c]['char'] === word.charAt(i)
                 let can_place_here = is_empty || is_intersection
                 if (!can_place_here) return false
             }
@@ -332,10 +347,10 @@ class Crossword {
                 r < this.grid.length && c < col + word.length;
                 c++, i++
             ) {
-                let is_empty = this.grid[r][c] == null
+                let is_empty = this.grid[r][c] === null
                 let is_intersection =
-                    this.grid[row][c] != null &&
-                    this.grid[row][c]['char'] == word.charAt(i)
+                    this.grid[row][c] !== null &&
+                    this.grid[row][c]['char'] === word.charAt(i)
                 let can_place_here = is_empty || is_intersection
                 if (!can_place_here) return false
             }
@@ -348,15 +363,15 @@ class Crossword {
                 if (result === false) return false
                 intersections += result
             }
-        } else if (direction == 'down') {
+        } else if (direction === 'down') {
             // out of bounds
             if (row + word.length > this.grid.length) return false
             // can't have a word directly above
-            if (row - 1 >= 0 && this.grid[row - 1][col] != null) return false
+            if (row - 1 >= 0 && this.grid[row - 1][col] !== null) return false
             // can't have a word directly below
             if (
                 row + word.length < this.grid.length &&
-                this.grid[row + word.length][col] != null
+                this.grid[row + word.length][col] !== null
             )
                 return false
 
@@ -369,10 +384,10 @@ class Crossword {
                 c >= 0 && r < row + word.length;
                 r++, i++
             ) {
-                let is_empty = this.grid[r][c] == null
+                let is_empty = this.grid[r][c] === null
                 let is_intersection =
-                    this.grid[r][col] != null &&
-                    this.grid[r][col]['char'] == word.charAt(i)
+                    this.grid[r][col] !== null &&
+                    this.grid[r][col]['char'] === word.charAt(i)
                 let can_place_here = is_empty || is_intersection
                 if (!can_place_here) return false
             }
@@ -383,10 +398,10 @@ class Crossword {
                 r < row + word.length && c < this.grid[r].length;
                 r++, i++
             ) {
-                let is_empty = this.grid[r][c] == null
+                let is_empty = this.grid[r][c] === null
                 let is_intersection =
-                    this.grid[r][col] != null &&
-                    this.grid[r][col]['char'] == word.charAt(i)
+                    this.grid[r][col] !== null &&
+                    this.grid[r][col]['char'] === word.charAt(i)
                 let can_place_here = is_empty || is_intersection
                 if (!can_place_here) return false
             }
@@ -409,24 +424,24 @@ class Crossword {
         return Math.floor(Math.random() * 2) ? 'across' : 'down'
     }
 
-    public findPositionForWord(word) {
-        // check the char_index for every letter, and see if we can put it there in a direction
+    public findPositionForWord(word: any) {
+        // check the charIndex for every letter, and see if we can put it there in a direction
         let bests: object[] = []
-        for (var i = 0; i < word.length; i++) {
-            var possible_locations_on_grid = this.char_index[word.charAt(i)]
+        for (let i = 0; i < word.length; i++) {
+            const possible_locations_on_grid = this.charIndex[word.charAt(i)]
             if (!possible_locations_on_grid) continue
-            for (var j = 0; j < possible_locations_on_grid.length; j++) {
-                var point = possible_locations_on_grid[j]
-                var r = point['row']
-                var c = point['col']
+            for (let j = 0; j < possible_locations_on_grid.length; j++) {
+                const point = possible_locations_on_grid[j]
+                const r = point['row']
+                const c = point['col']
                 // the c - i, and r - i here compensate for the offset of character in the word
-                var intersections_across = this.canPlaceWordAt(
+                const intersections_across = this.canPlaceWordAt(
                     word,
                     r,
                     c - i,
                     'across'
                 )
-                var intersections_down = this.canPlaceWordAt(
+                const intersections_down = this.canPlaceWordAt(
                     word,
                     r - i,
                     c,
@@ -434,7 +449,7 @@ class Crossword {
                 )
 
                 if (intersections_across !== false) {
-                    var objectAcross = {
+                    const objectAcross = {
                         intersections: intersections_across,
                         row: r,
                         col: c - i,
@@ -443,7 +458,7 @@ class Crossword {
                     bests.push(objectAcross)
                 }
                 if (intersections_down !== false) {
-                    var objectDown = {
+                    const objectDown = {
                         intersections: intersections_down,
                         row: r - i,
                         col: c,
@@ -454,22 +469,85 @@ class Crossword {
             }
         }
 
-        if (bests.length == 0) return false
+        if (bests.length === 0) return false
 
         // find a good random position
-        var best = bests[Math.floor(Math.random() * bests.length)]
-
-        return best
+        return bests[Math.floor(Math.random() * bests.length)]
     }
 
     public clear() {
-        for (var r = 0; r < this.grid.length; r++) {
-            for (var c = 0; c < this.grid[r].length; c++) {
+        for (let r = 0; r < this.grid.length; r++) {
+            for (let c = 0; c < this.grid[r].length; c++) {
                 this.grid[r][c] = null
             }
         }
-        this.char_index = {}
+        this.charIndex = {}
+    }
+}
+
+class CrosswordUtils {
+    public static PATH_TO_PNGS_OF_NUMBERS: string = 'numbers/'
+
+    public static toHtml(grid: any, show_answers: any) {
+        if (grid === null) return
+        const html: Array<string> = []
+        html.push("<table class='crossword'>")
+        let label = 1
+        for (let r = 0; r < grid.length; r++) {
+            html.push('<tr>')
+            for (let c = 0; c < grid[r].length; c++) {
+                const cell = grid[r][c]
+                let isStartOfWord = false
+                let css_class, char
+                if (cell === null) {
+                    char = '&nbsp;'
+                    css_class = 'no-border'
+                } else {
+                    char = cell['char']
+                    css_class = ''
+                    isStartOfWord =
+                        (cell.across && cell.across.isStartOfWord) ||
+                        (cell.down && cell.down.isStartOfWord)
+                }
+
+                if (isStartOfWord) {
+                    const img_url =
+                        this.PATH_TO_PNGS_OF_NUMBERS + label.toString() + '.png'
+                    html.push(
+                        "<td class='" +
+                            css_class +
+                            "' title='" +
+                            r +
+                            ', ' +
+                            c +
+                            "' style=\"background-image:url('" +
+                            img_url +
+                            '\')">'
+                    )
+                    label++
+                } else {
+                    html.push(
+                        "<td class='" +
+                            css_class +
+                            "' title='" +
+                            r +
+                            ', ' +
+                            c +
+                            "'>"
+                    )
+                }
+
+                if (show_answers) {
+                    html.push(char)
+                } else {
+                    html.push('&nbsp;')
+                }
+            }
+            html.push('</tr>')
+        }
+        html.push('</table>')
+        return html.join('\n')
     }
 }
 
-export { Crossword }
+export { Crossword, CrosswordUtils }