board_col_heights = [5, 6, 7, 8, 7, 6, 5]
+# code and css will need adjusting if you change HP_MAX
+HP_MAX = 10
##############################################################
############## fix javascript some more ################
board_tiles = board_col_heights.sum()
board_col_top_px = []
score = 0
-board = new Array(board_tiles) # letters ("Qu" or single letter)
+tiles = new Array(board_tiles)
board_neighbors = [] # array of tile numbers "next to" this one
-board_top_px = [] # array of pixel coordinates for top of column
+tile_top_px = [] # array of pixel coordinates for top of column
board_left_px = [] # array of pixel coordinates for left of column
board_aboves = [] # array of tile numbers above, starting from top
board_below = [] # tile number of next tile below or false
-slides = []
selected = []
letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
new_letter = ->
if new_letter_queue.length
l = new_letter_queue.shift()
- if l is 'Q'
- return 'Qu'
- else
- return l
+ l.letter = l.letter.toUpperCase()
+ if l.letter is 'Q'
+ l.letter = 'Qu'
+ return l
+ hp = 1 + Math.floor(Math.random() * (HP_MAX - 1))
r = Math.floor Math.random() * (letter_distribution_total + 1)
for i in [0..25]
r -= letter_distribution[i]
if r <= 0
if letters[i] is 'Q'
- return 'Qu'
- return letters[i]
- return 'Z' # just in case
+ return letter: 'Qu', hp: hp
+ return letter: letters[i], hp: hp
+ return letter: 'Z', hp: hp # just in case
is_bottom_tile = i is board_col_heights[col_num] - 1
# link tile number to pixel "top" and "left" of containing column
- board_top_px.push col_top_px
+ tile_top_px.push col_top_px + i * tile_width
board_left_px.push col_num * tile_width
# aboves (array of tile numbers above, starting from top)
col_offset += board_col_heights[col_num]
+# support obsolete save data format
+load_game_0 = (encoded) ->
+ letters = (encoded.substr 0, board_tiles).split ''
+ for l in letters
+ new_letter_queue.push {
+ letter: l,
+ hp: 1 + Math.floor(Math.random() * (HP_MAX - 1))
+ }
+ score = parseInt(encoded.substr(board_tiles), 10)
+
+load_game_1 = (encoded) ->
+ int = 0
+ encoded = encoded.substr 1
+ score = parseInt(encoded.substr(board_tiles * 3 / 2), 10)
+ for t in [0...(tiles.length * 3 / 2)] by 3
+ int = 0
+ for d in [0...3]
+ int *= 44
+ char = encoded[t + 2 - d]
+ int += save_charset.indexOf(char)
+ t2hp = int % 11
+ int = Math.floor(int / 11)
+ t2letter = String.fromCharCode(char_a + (int % 26))
+ int = Math.floor(int / 26)
+ t1hp = int % 11
+ int = Math.floor(int / 11)
+ t1letter = String.fromCharCode(char_a + (int % 26))
+ new_letter_queue.push {
+ letter: t1letter,
+ hp: t1hp
+ }
+ new_letter_queue.push {
+ letter: t2letter,
+ hp: t2hp
+ }
+
+load_game = (encoded) ->
+ switch encoded.substr 0, 1
+ when "1"
+ load_game_1(encoded)
+ else
+ load_game_0(encoded)
init_board = ->
encoded = window.location.hash
unless encoded? and encoded.length > board_tiles
encoded = get_cookie 'hexbog'
if encoded? and encoded.length > board_tiles
- new_letter_queue = (encoded.substr 0, board_tiles).split ''
- score = parseInt(encoded.substr(board_tiles), 10)
-
- # how far each tile needs to be slid down
- slides = (0 for i in board)
+ load_game encoded
# work out which grid spaces are connected
# (neighbors, above, down)
init_board_layout()
-$selection_display = null # initialized by init_html_board
+$big_tip = null # initialized by init_html_board
+$little_tip = null # initialized by init_html_board
$score_display = null # initialized by init_html_board
$definition_body = null # initialized by init_html_board
update_selection_display = ->
word = selected_word()
- $selection_display.html word
+ $big_tip.removeClass('good')
+ if word.length > 0
+ if word.length < 3
+ $big_tip.html word
+ $little_tip.html "Click more tiles (3 minimum)"
+ else
+ if is_word word
+ if word.indexOf(word.substr(word.length - 1)) < word.length - 1
+ last = 'last '
+ else
+ last = ''
+ $little_tip.html "Click the #{last}\"#{word.substr(word.length - 1)}\" for #{score_for word} points"
+ $big_tip.html "<a href=\"http://en.wiktionary.org/wiki/#{word}\" target=\"_blank\" title=\"click for definition\">#{word}</a>"
+ $big_tip.addClass('good')
+ else
+ $big_tip.html word
+ $little_tip.html "\"#{word}\" is not in the word list."
+ else
+ $big_tip.html "← Click a word"
+ $little_tip.html "(tiles must be touching)"
# color the selected tiles according to whether they're a word or not
if word.length
else
c = 1
for num in selected
- html_tiles[num].addClass classes[c]
- html_tiles[num].removeClass classes[1 - c]
+ tiles[num].dom.addClass classes[c]
+ tiles[num].dom.removeClass classes[1 - c]
# unselects the last tile of the selecetion
unselect_tile = ->
_unselect_tile = ->
num = selected.pop()
- html_tile = html_tiles[num]
+ html_tile = tiles[num].dom
html_tile.removeClass 'selected_word'
html_tile.removeClass 'selected'
_unselect_tile()
update_selection_display()
-shrink_selection = (leave_count) ->
- while selected.length > leave_count
- _unselect_tile()
- update_selection_display()
-
selected_word = ->
word = ''
- word += board[i] for i in selected
+ word += tiles[i].text for i in selected
return word.toLowerCase()
-html_slide = (num, dist) ->
- if dist
- cur = html_tiles[num].css 'top'
- cur = Number(cur.substr(0, cur.length - 2))
- dest = cur + (dist * tile_width)
- html_tiles[num].animate {top: "#{dest}px"}, slide_ms
-
+save_charset = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQR'
+char_a = "a".charCodeAt(0)
save_game = ->
- encoded = ''
- for t in board
- encoded += t.substr 0, 1
+ encoded = '1' # save format
+ for i in [0...tiles.length] by 2
+ int = tiles[i].text.toLowerCase().charCodeAt(0) - char_a
+ int *= 11
+ int += tiles[i].hp
+ int *= 26
+ int += tiles[i+1].text.toLowerCase().charCodeAt(0) - char_a
+ int *= 11
+ int += tiles[i+1].hp
+ for d in [0...3]
+ encoded += save_charset.substr(int % 44, 1)
+ int = Math.floor(int / 44)
encoded += score
set_cookie 'hexbog', encoded, 365
window.location.hash = encoded
+unsink = (tile) ->
+ tile.new_hp = 10
+ tile.text = new_letter().letter
+ tile.dom.html tile.text
+
+# remove the selected tiles from the board, create new tiles, and slide everything into place
blip_selection = ->
- faders = selected.clone().num_sort()
+ difficulty = 11 - Math.log(400 + score) # higher numbers are easier
+ force = difficulty * score_for selected_word() # how much tile restoration we have left to do
+ word_length = selected_word().length
+ faders = selected.num_sort()
selected = []
- for num in faders
- html_tiles[num].unbind('click').fadeOut fade_ms
- timeout fade_ms, ->
- top_tile = -1
- new_px = 0
- new_slide = 0
- for fader in faders
- cur_top = board_aboves[fader][0]
- if cur_top is undefined
- cur_top = fader
- if top_tile isnt cur_top
- new_px = board_top_px[fader] - tile_width
- new_slide = 1
- top_tile = cur_top
- html_tiles[fader].remove()
- dest = fader
- aboves = board_aboves[fader].clone().reverse()
+ update_selection_display()
+ neighbors = {}
+ nneighbors = {}
+ for i in faders
+ tiles[i].dom.unbind('click').fadeOut fade_ms
+ tiles[i].new_hp = tiles[i].hp
+ for n in board_neighbors[i]
+ neighbors[n] = tiles[n]
+ for nn in board_neighbors[n]
+ nneighbors[nn] = tiles[nn]
+ for i in faders
+ delete nneighbors[i]
+ delete neighbors[i]
+ for k, v of neighbors
+ delete nneighbors[k]
+ # convert to arrays so we can sort, etc
+ nneighbors = (v for k, v of nneighbors)
+ neighbors = (v for k, v of neighbors)
+ boom = [
+ {
+ tiles: neighbors,
+ up: [],
+ down: []
+ },
+ {
+ tiles: nneighbors,
+ up: [],
+ down: []
+ }
+ ]
+ for n in boom
+ for t in n.tiles
+ if t.hp is 0
+ n.down.push t
+ else
+ n.up.push t
+ switch word_length
+ when 3
+ boom[0].flips = 1
+ boom[0].force = 2
+ boom[1].flips = 0
+ boom[1].force = 0
+ when 4
+ boom[0].flips = 'all'
+ boom[0].force = 4
+ boom[1].flips = 0
+ boom[1].force = 2
+ when 5
+ boom[0].flips = 'all'
+ boom[0].force = 6
+ boom[1].flips = 2
+ boom[1].force = 4
+ when 6
+ boom[0].flips = 'all'
+ boom[0].force = 10
+ boom[1].flips = 5
+ boom[1].force = 6
+ when 7
+ boom[0].flips = 'all'
+ boom[0].force = 10
+ boom[1].flips = 'all'
+ boom[1].force = 10
+ else
+ boom[0].flips = 0
+ boom[0].force = 0
+ boom[1].flips = 0
+ boom[1].force = 0
+ # unsink/heal the whole board
+ for t in tiles
+ if t.hp is 0
+ unsink t
+ else
+ t.new_hp = 10
+ for b in boom
+ if b.flips is 'all' or b.flips >= b.down.length
+ for t in b.down
+ unsink t
+ else
+ down_count = b.down.length
+ while b.flips > 0 and down_count
+ b.flips -= 1
+ flipper = Math.floor(Math.random() * down_count)
+ unsink b.down[flipper]
+ down_count -= 1
+ # move the last tile back into range
+ b.down[flipper] = b.down[down_count]
+ if b.force > 0
+ for t in b.up
+ t.new_hp = t.hp + b.force
+ for i in tiles
+ i.new_hp ?= i.hp - 1
+ if i.new_hp < 0
+ i.new_hp = 0
+ else if i.new_hp > HP_MAX
+ i.new_hp = HP_MAX
+ if i.new_hp isnt i.hp
+ i.dom.removeClass "hp#{i.hp}"
+ i.dom.addClass "hp#{i.new_hp}"
+ i.hp = i.new_hp
+ delete i.new_hp
+ timeout fade_ms + 1, ->
+ # which tiles need to be slid down
+ sliders = (false for i in tiles)
+
+ prev_col_top = null
+ next_new_y = null
+ for deleted in faders
+ # find the tile number of the top tile in this column
+ if board_aboves[deleted].length is 0
+ col_top = deleted
+ else
+ col_top = board_aboves[deleted][0]
+
+ # reset location where new tiles appear when we change columns
+ if prev_col_top isnt col_top
+ next_new_y = -10 - tile_width
+ prev_col_top = col_top
+
+ tiles[deleted].dom.remove()
+
+ # For each each tile above the one we've deleted:
+ # 1. move it down one slot in the data scructures
+ # 2. mark it as needing to slide
+ dest = deleted
+ aboves = board_aboves[deleted].clone().reverse()
for above in aboves
- html_tiles[dest] = html_tiles[above]
- html_tiles[dest].data 'tile_number', dest
- board[dest] = board[above]
- slides[dest] = slides[above] + 1
+ tiles[dest] = tiles[above]
+ tiles[dest].id = dest
+ tiles[dest].dom.data 'tile_number', dest
+ sliders[dest] = true
--dest
- new_tile top_tile, board_left_px[top_tile], new_px
- slides[top_tile] = new_slide
- new_px -= tile_width
- new_slide += 1
- for i in [0 .. board.length - 1]
- html_slide i, slides[i]
- slides[i] = 0
+ sliders[col_top] = true # the new tile needs to be slid down too
+
+ new_tile col_top, board_left_px[col_top], next_new_y
+ next_new_y -= tile_width + 50
+
+ for slide, i in sliders
+ if slide
+ tiles[i].dom.animate {top: "#{tile_top_px[i]}px"}, slide_ms
+ sliders[i] = false
save_game()
- update_selection_display()
+
+score_for = (word) -> Math.round(Math.pow(1.7, word.length))
activate_selection = ->
word = selected_word()
if word.length < 3
+ # FIXME make this a hint
log "Too short: \"#{word}\""
return
unless is_word word
+ # FIXME make this automatically part of the selection display
log "Not on word list: \"#{word}\""
return
- word_score = Math.round(Math.pow(1.7, word.length))
+ word_score = score_for word
score += word_score
$score_display.html score
+ # FIXME make some kind of animation showing score gain
log "blipped \"#{word}\" for #{word_score} points"
blip_selection()
look_up_definition word
select_tile = (num) ->
- html_tile = html_tiles[num]
+ html_tile = tiles[num].dom
# html_tile.css backgroundColor: tile_selected_color
selected.push num
update_selection_display()
return
new_tile = (num, x, y) ->
- letter = new_letter()
+ l = new_letter()
+ letter = l.letter
+ hp = l.hp
- html_tile = $("<div class=\"tile\" style=\"left: #{x}px; top: #{y}px\" unselectable=\"on\">#{letter}</div>")
+ html_tile = $("<div class=\"tile hp#{hp}\" style=\"left: #{x}px; top: #{y}px\" unselectable=\"on\">#{letter}</div>")
$board.append(html_tile)
html_tile.data 'tile_number', num
- board[num] = letter
- html_tiles[num] = html_tile
+ tiles[num] = text: letter, dom: html_tile, hp: hp, id: num
html_tile.click ->
me = $(this)
num = me.data 'tile_number'
+ return if tiles[num].hp < 1
if num in selected
- nth_of_word = selected.indexOf(num)
- first = nth_of_word is 0
- last = nth_of_word is selected.length - 1
-
- if first and last
- unselect_all() # Clicking only selected letter unselects it
- else if first and !last
- shrink_selection 1 # Clicking start of word goes back to just that letter
- # should this unselect all?
- else if last
+ if selected_word().length > 2 and num is selected.last()
activate_selection()
else
- shrink_selection nth_of_word + 1
- else # (not clicking on selected tile)
- if selected.length is 0
- select_tile num
- else
- unless num in board_neighbors[selected.last()]
+ if selected.length > 1
+ unselect_all()
+ select_tile num
+ else
unselect_all()
- select_tile num
+ else # (not clicking on selected tile)
+ if selected.length > 0 and not (num in board_neighbors[selected.last()])
+ unselect_all()
+ select_tile num
$board = null
-html_tiles = []
init_html_board = ->
$('#loading').remove()
- $selection_display = $('#selection')
+ $big_tip = $('#big_tip')
+ $little_tip = $('#little_tip')
$score_display = $('#score')
$score_display.html score
$definition_body = $('#definition_body')
valid_parts = ["Abbreviation", "Adjective", "Adverb", "Article", "Cardinal number", "Conjunction", "Determiner", "Interjection", "Noun", "Numeral", "Particle", "Preposition", "Pronoun", "Verb"]
+ edit_link_regex = new RegExp(' ?\\[edit\\] ?')
+
elements.each (i, el) ->
#which tag: el.tagName
if el.tagName is 'H2'
if found
return false # break
part = false # mark us not being in a definition section unless the next section finds a part of speach header
- language = $(el).text().substr 7
+ language = $(el).text().replace(edit_link_regex, '')
if language and el.tagName is 'H3' or el.tagName is 'H4' # eg yak def uses one for english and one for dutch
part = false
- text = $(el).text()
+ text = $(el).text().replace(edit_link_regex, '')
for p in valid_parts
- if text is "[edit] #{p}"
+ if text is "#{p}"
part = p.toLowerCase()
# FIXME break
if part and el.tagName is 'OL'
$(el).children().each (i, el) ->
new_def = $(el).text()
- if new_def.substr(0, 9) is '(obsolete' or new_def.substr(0, 8) is "(archaic"
- key = 'obsolete'
+ if new_def.substr(0, 9) is '(obsolete' or new_def.substr(0, 8) is "(archaic" or new_def.substr(0, 20) is "Alternative form of " or new_def.substr(0, 24) is "Alternative spelling of "
+ key = 'lame'
else
if part is 'verb'
key = 'verb'
if found.verb
return false # break
- part_defs = (finds[i] for i in ['verb', 'nonverb', 'obsolete'] when finds[i])
+ part_defs = (finds[i] for i in ['verb', 'nonverb', 'lame'] when finds[i])
unless part_defs.length
return false
look_up_definition = (word) ->
+ $definition_body.html "Looking up definition for \"#{word}\"..."
$.ajax({
url: "http://en.wiktionary.org/w/api.php?action=parse&format=json&page=#{word}"
jsonpCallback: "lud_#{word}" # always use the same callback for the same word so it's cacheable
tdl = extract_wiktionary_definiton data.parse.text['*']
if tdl
show_definition word, tdl[0], tdl[1], tdl[2]
+ else
+ $definition_body.html "Oops, could't find a definition for \"#{word}\"."
else
- log "Sorry, couldn't find a definition for \"#{word}\""
- error: ->
- log "wiktionary failed to load: \"#{error_msg}\""
+ $definition_body.html "Sorry, couldn't find a definition for \"#{word}\"."
})
board_as_txt = ->
index = 0
for i in [0 .. board_min_height * 2]
unless i % 2
- ret += ' ' + board[j] for j in [board_min_height + index .. board_tiles - 1] by 2 * board_min_height + 1
+ ret += ' ' + tiles[j].text for j in [board_min_height + index .. board_tiles - 1] by 2 * board_min_height + 1
else
- ret += ' ' + board[j] + ' ' for j in [index .. board_tiles - 1] by 2 * board_min_height + 1
+ ret += ' ' + tiles[j].text + ' ' for j in [index .. board_tiles - 1] by 2 * board_min_height + 1
index += 1
ret += '\n'
when 27
unselect_all()
-$log = undefined
-init_log = ->
- $log = $('#log')
log = (msg) ->
- console.log msg if console.log?
+ console.log msg if console?.log?
init_game = ->
- init_log()
if $(window).height() >= 440
$('#centerer').css('margin-top', '25px')
init_keybinding()
init_board()
init_html_board()
init_start_over_link()
+ update_selection_display()
$(init_game)