@windward/games 0.0.2 → 0.0.4

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

@@ -0,0 +1,475 @@
+import {
+    CrosswordCell,
+    CrosswordCellNode,
+    WordElement,
+} from './CrosswordElements'
+class Crossword {
+    public GRID_COLS: any = 50
+    public GRID_ROWS: any = 50
+    // 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!: {}
+    // 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 grid: any = []
+    public word_elements: any = []
+    constructor(words_in, clues_in) {
+        this.words_in = words_in
+        this.clues_in = clues_in
+        // constructor
+        if (this.words_in.length < 2)
+            throw 'A crossword must have at least 2 words'
+        if (this.words_in.length != clues_in.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++) {
+            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))
+        }
+
+        // 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) {
+            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) {
+                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
+            }
+
+            if (best_ratio == 1) break
+        }
+        return best_grid
+    }
+
+    // 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
+            // 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)
+
+            var word_element = this.word_elements[0]
+            if (start_dir == 'across') {
+                c -= Math.floor(word_element.word.length / 2)
+            } else {
+                r -= Math.floor(word_element.word.length / 2)
+            }
+
+            if (
+                this.canPlaceWordAt(word_element.word, r, c, start_dir) !==
+                false
+            ) {
+                this.placeWordAt(
+                    word_element.word,
+                    word_element.index,
+                    r,
+                    c,
+                    start_dir
+                )
+            } else {
+                this.bad_words = [word_element]
+                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
+                // 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
+                    )
+                    if (!best_position) {
+                        // make the new group (if needed)
+                        if (groups.length - 1 == g) groups.push([])
+                        // place the word in the next group
+                        groups[g + 1].push(word_element)
+                    } else {
+                        ;(r = best_position['row']), (c = best_position['col'])
+                        var dir = best_position['direction']
+                        this.placeWordAt(
+                            word_element.word,
+                            word_element.index,
+                            r,
+                            c,
+                            dir
+                        )
+                        word_has_been_added_to_grid = 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
+            }
+            // no need to try again
+            if (word_has_been_added_to_grid) return this.minimizeGrid()
+        }
+
+        this.bad_words = groups[groups.length - 1]
+        return null
+    }
+
+    // returns the list of WordElements that can't fit on the crossword
+    public getBadWords() {
+        return this.bad_words
+    }
+
+    // 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
+                // check across and down
+                for (var k 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({
+                            position: position,
+                            index: index,
+                            clue: this.clues_in[index],
+                            word: this.words_in[index],
+                        })
+                        increment_position = true
+                    }
+                }
+
+                if (increment_position) position++
+            }
+        }
+        return groups
+    }
+
+    // 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) {
+                    if (r < r_min) r_min = r
+                    if (r > r_max) r_max = r
+                    if (c < c_min) c_min = c
+                    if (c > c_max) c_max = c
+                }
+            }
+        }
+        // initialize new grid
+        var rows = r_max - r_min + 1
+        var cols = c_max - c_min + 1
+        var 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)
+            }
+        }
+
+        // copy the grid onto the smaller grid
+        for (let r = r_min, r2 = 0; r2 < rows; r++, r2++) {
+            for (let c = c_min, c2 = 0; c2 < cols; c++, c2++) {
+                new_grid[r2][c2] = this.grid[r][c]
+            }
+        }
+
+        return new_grid
+    }
+
+    // helper for placeWordAt();
+    public addCellToGrid(
+        word,
+        index_of_word_in_input_list,
+        index_of_char,
+        r,
+        c,
+        direction
+    ) {
+        var char = word.charAt(index_of_char)
+        if (this.grid[r][c] == null) {
+            this.grid[r][c] = new CrosswordCell(char)
+
+            // init the char_index for that character if needed
+            if (!this.char_index[char]) this.char_index[char] = []
+
+            // add to index
+            this.char_index[char].push({ row: r, col: c })
+        }
+
+        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
+        )
+    }
+
+    // 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') {
+            for (let c = col, i = 0; c < col + word.length; c++, i++) {
+                this.addCellToGrid(
+                    word,
+                    index_of_word_in_input_list,
+                    i,
+                    row,
+                    c,
+                    direction
+                )
+            }
+        } 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,
+                    i,
+                    r,
+                    col,
+                    direction
+                )
+            }
+        } else {
+            throw 'Invalid Direction'
+        }
+    }
+
+    // you can only place a char where the space is blank, or when the same
+    // character exists there already
+    // 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) {
+        // no intersection
+        if (this.grid[row][col] == null) return 0
+        // intersection!
+        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 {
+        // out of bounds
+        if (
+            row < 0 ||
+            row >= this.grid.length ||
+            col < 0 ||
+            col >= this.grid[row].length
+        )
+            return false
+
+        var intersections
+
+        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
+            // can't have word directly to the right
+            if (
+                col + word.length < this.grid[row].length &&
+                this.grid[row][col + word.length] != null
+            )
+                return false
+
+            // check the row above to make sure there isn't another word
+            // running parallel. It is ok if there is a character above, only if
+            // the character below it intersects with the current word
+            for (
+                let r = row - 1, c = col, i = 0;
+                r >= 0 && c < col + word.length;
+                c++, i++
+            ) {
+                let is_empty = this.grid[r][c] == null
+                let is_intersection =
+                    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
+            }
+
+            // same deal as above, we just search in the row below the word
+            for (
+                let r = row + 1, c = col, i = 0;
+                r < this.grid.length && c < col + word.length;
+                c++, i++
+            ) {
+                let is_empty = this.grid[r][c] == null
+                let is_intersection =
+                    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
+            }
+
+            // check to make sure we aren't overlapping a char (that doesn't match)
+            // and get the count of intersections
+            intersections = 0
+            for (let c = col, i = 0; c < col + word.length; c++, i++) {
+                let result = this.canPlaceCharAt(word.charAt(i), row, c)
+                if (result === false) return false
+                intersections += result
+            }
+        } 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
+            // can't have a word directly below
+            if (
+                row + word.length < this.grid.length &&
+                this.grid[row + word.length][col] != null
+            )
+                return false
+
+            // check the column to the left to make sure there isn't another
+            // word running parallel. It is ok if there is a character to the
+            // left, only if the character to the right intersects with the
+            // current word
+            for (
+                let c = col - 1, r = row, i = 0;
+                c >= 0 && r < row + word.length;
+                r++, i++
+            ) {
+                let is_empty = this.grid[r][c] == null
+                let is_intersection =
+                    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
+            }
+
+            // same deal, but look at the column to the right
+            for (
+                let c = col + 1, r = row, i = 0;
+                r < row + word.length && c < this.grid[r].length;
+                r++, i++
+            ) {
+                let is_empty = this.grid[r][c] == null
+                let is_intersection =
+                    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
+            }
+
+            // check to make sure we aren't overlapping a char (that doesn't match)
+            // and get the count of intersections
+            intersections = 0
+            for (let r = row, i = 0; r < row + word.length; r++, i++) {
+                let result = this.canPlaceCharAt(word.charAt(i, 1), r, col)
+                if (result === false) return false
+                intersections += result
+            }
+        } else {
+            throw 'Invalid Direction'
+        }
+        return intersections
+    }
+
+    public randomDirection() {
+        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
+        let bests: object[] = []
+        for (var i = 0; i < word.length; i++) {
+            var possible_locations_on_grid = this.char_index[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']
+                // the c - i, and r - i here compensate for the offset of character in the word
+                var intersections_across = this.canPlaceWordAt(
+                    word,
+                    r,
+                    c - i,
+                    'across'
+                )
+                var intersections_down = this.canPlaceWordAt(
+                    word,
+                    r - i,
+                    c,
+                    'down'
+                )
+
+                if (intersections_across !== false) {
+                    var objectAcross = {
+                        intersections: intersections_across,
+                        row: r,
+                        col: c - i,
+                        direction: 'across',
+                    }
+                    bests.push(objectAcross)
+                }
+                if (intersections_down !== false) {
+                    var objectDown = {
+                        intersections: intersections_down,
+                        row: r - i,
+                        col: c,
+                        direction: 'down',
+                    }
+                    bests.push(objectDown)
+                }
+            }
+        }
+
+        if (bests.length == 0) return false
+
+        // find a good random position
+        var best = bests[Math.floor(Math.random() * bests.length)]
+
+        return best
+    }
+
+    public clear() {
+        for (var r = 0; r < this.grid.length; r++) {
+            for (var c = 0; c < this.grid[r].length; c++) {
+                this.grid[r][c] = null
+            }
+        }
+        this.char_index = {}
+    }
+}
+
+export { Crossword }

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

@@ -0,0 +1,36 @@
+class CrosswordCell {
+    public char!: any
+    public across!: any
+    public down!: any
+    constructor(letter) {
+        this.char = letter // the actual letter for the cell on the crossword
+        // If a word hits this cell going in the "across" direction, this will be a CrosswordCellNode
+        this.across = null
+        // If a word hits this cell going in the "down" direction, this will be a CrosswordCellNode
+        this.down = null
+    }
+}
+
+// You can tell if the Node is the start of a word (which is needed if you want to number the cells)
+// and what word and clue it corresponds to (using the index)
+class CrosswordCellNode {
+    public is_start_of_word!: any
+    public index!: any
+    constructor(is_start_of_word, index) {
+        this.is_start_of_word = is_start_of_word
+        this.index = index // use to map this node to its word or clue
+    }
+
+    // public functionName
+}
+
+class WordElement {
+    public word!: any
+    public index!: any
+    constructor(word, index) {
+        this.word = word // the actual word
+        this.index = index // use to map this node to its word or clue
+    }
+}
+
+export { CrosswordCell, CrosswordCellNode, WordElement }