X-Git-Url: https://jasonwoof.com/gitweb/?p=hexbog.git;a=blobdiff_plain;f=main.coffee;h=147b76a2ff4680e47cd7b2881ea122ae5aac5db2;hp=04670557f2d7211008a21202d1ba4204e240f6bd;hb=643696e68d5a23c907592334432796738fcc288c;hpb=0b70e4b47604d7a6ee1f851c31bb5ce2f6410044
diff --git a/main.coffee b/main.coffee
index 0467055..147b76a 100644
--- a/main.coffee
+++ b/main.coffee
@@ -24,8 +24,18 @@ tile_width = tile_radius * 2
fade_ms = 400
slide_ms = 2000
-board_col_heights = [5, 6, 7, 8, 7, 6, 5]
+columns = [
+ { height: 5, spaces: [], fader_count: 0 }
+ { height: 6, spaces: [], fader_count: 0 }
+ { height: 7, spaces: [], fader_count: 0 }
+ { height: 8, spaces: [], fader_count: 0 }
+ { height: 7, spaces: [], fader_count: 0 }
+ { height: 6, spaces: [], fader_count: 0 }
+ { height: 5, spaces: [], fader_count: 0 }
+]
+# code and css will need adjusting if you change HP_MAX
+HP_MAX = 10
##############################################################
############## fix javascript some more ################
@@ -44,9 +54,6 @@ Array::sum = ->
ret += i for i in this
return ret
-# ascending. All values must be Numbers
-Array::num_sort = -> return this.sort((a, b) -> return a - b)
-
Array::last = ->
return this[this.length - 1]
@@ -74,16 +81,10 @@ delete_cookie = (name) ->
window.dc = delete_cookie
-board_cols = board_col_heights.length
-board_tiles = board_col_heights.sum()
-board_col_top_px = []
+num_spaces = 0
+num_spaces += column.height for column in columns
score = 0
-board = new Array(board_tiles) # letters ("Qu" or single letter)
-board_neighbors = [] # array of tile numbers "next to" this one
-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
+spaces = new Array(num_spaces)
selected = []
@@ -125,18 +126,19 @@ new_letter_queue = []
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
@@ -157,49 +159,54 @@ new_letter = ->
# work out which grid spaces are connected
init_board_layout = () ->
col_offset = 0
- middle_col = (board_cols - 1) / 2
+ middle_col_num = (columns.length - 1) / 2
- # how many tiles before the current tile?
- for col_num in [0 .. board_cols - 1]
- if col_num < middle_col
+ space_num = 0
+
+ for column, col_num in columns
+ if col_num < middle_col_num
fw_other = 1
else
fw_other = -1
- if col_num > middle_col
+ if col_num > middle_col_num
bw_other = 1
else
bw_other = -1
is_first_col = col_num is 0
- is_last_col = col_num is board_cols - 1
+ is_last_col = col_num is columns.length - 1
neighbors = []
+ # neighbors are integers for now, but get dereferenced later, after we've created all the spaces
push = (offset) ->
neighbors.push col_offset + offset
- col_top_px = Math.abs col_num - middle_col
+ col_top_px = Math.abs col_num - middle_col_num
col_top_px *= tile_radius
- board_col_top_px.push col_top_px
above = []
- for i in [0 .. board_col_heights[col_num] - 1]
+ for i in [0 ... column.height]
+ space = { id: space_num }
+ spaces[space_num] = space
+ space_num += 1
+ column.spaces.push space
+ space.column = column
+
is_top_tile = i is 0
- is_bottom_tile = i is board_col_heights[col_num] - 1
+ is_bottom_tile = i is column.height - 1
# link tile number to pixel "top" and "left" of containing column
- tile_top_px.push col_top_px + i * tile_width
- board_left_px.push col_num * tile_width
+ space.top_px = col_top_px + i * tile_width
+ space.left_px = col_num * tile_width
- # aboves (array of tile numbers above, starting from top)
- board_aboves.push above.clone()
- above.push i + col_offset
+ # aboves: array of spaces, top to bottom
+ space.aboves = above.clone()
+ above.push space
- # below (SINGLE tile number of tile below or false)
- if is_bottom_tile
- board_below.push false
- else
- board_below.push col_offset + i + 1
+ # below: SINGLE tile below
+ unless is_top_tile
+ spaces[space.id - 1].below = space
# neighbors (array of tile numbers "next to" this one)
neighbors = []
@@ -209,40 +216,104 @@ init_board_layout = () ->
push i + 1
unless is_first_col # leftward links
unless is_bottom_tile and bw_other is -1
- push i - board_col_heights[col_num - 1]
+ push i - columns[col_num - 1].height
unless is_top_tile and bw_other is -1
- push i - board_col_heights[col_num - 1] + bw_other
+ push i - columns[col_num - 1].height + bw_other
unless is_last_col # rightward links
unless is_bottom_tile and fw_other is -1
- push i + board_col_heights[col_num]
+ push i + columns[col_num].height
unless is_top_tile and fw_other is -1
- push i + board_col_heights[col_num] + fw_other
-
- board_neighbors.push neighbors.clone()
-
- col_offset += board_col_heights[col_num]
-
+ push i + columns[col_num].height + fw_other
+ # will be dereferenced later
+ space.neighbors = neighbors
+ col_offset += column.height
+ # convert all space.neighbors arrays from containing space ids to referencing the space
+ for s in spaces
+ for id, key in s.neighbors
+ s.neighbors[key] = spaces[id]
+
+# support obsolete save data format
+load_game_0 = (encoded) ->
+ letters = (encoded.substr 0, num_spaces).split ''
+ for l in letters
+ new_letter_queue.push {
+ letter: l,
+ hp: 1 + Math.floor(Math.random() * (HP_MAX - 1))
+ }
+ score = parseInt(encoded.substr(num_spaces), 10)
+
+load_game_1 = (encoded) ->
+ int = 0
+ encoded = encoded.substr 1
+ score = parseInt(encoded.substr(num_spaces * 3 / 2), 10)
+ for t in [0...(spaces.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
if encoded? and encoded.charAt 0 is '#'
encoded = encoded.substr 1
- unless encoded? and encoded.length > board_tiles
+ unless encoded? and encoded.length > num_spaces
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)
+ if encoded? and encoded.length > num_spaces
+ 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 "#{word} "
+ $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
@@ -251,9 +322,9 @@ update_selection_display = ->
c = 0
else
c = 1
- for num in selected
- html_tiles[num].addClass classes[c]
- html_tiles[num].removeClass classes[1 - c]
+ for tile in selected
+ tile.dom.addClass classes[c]
+ tile.dom.removeClass classes[1 - c]
# unselects the last tile of the selecetion
unselect_tile = ->
@@ -261,98 +332,290 @@ unselect_tile = ->
update_selection_display()
_unselect_tile = ->
- num = selected.pop()
- html_tile = html_tiles[num]
- html_tile.removeClass 'selected_word'
- html_tile.removeClass 'selected'
+ tile = selected.pop()
+ dom = tile.dom
+ if tile.connector?
+ tile.connector.remove()
+ delete tile.connector
+ dom.removeClass 'selected_word'
+ dom.removeClass 'selected'
unselect_all = ->
while selected.length
_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 += tile.text for tile in selected
return word.toLowerCase()
+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...spaces.length] by 2
+ int = spaces[i].tile.text.toLowerCase().charCodeAt(0) - char_a
+ int *= 11
+ int += spaces[i].tile.hp
+ int *= 26
+ int += spaces[i+1].tile.text.toLowerCase().charCodeAt(0) - char_a
+ int *= 11
+ int += spaces[i+1].tile.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
+
+
+# top-level key is word length
+# arrays are [difficulty] level, easiest to hardest
+booms = {
+ 3: {
+ neighbors: {
+ flips: [1,1,1,1,0]
+ force: [2,2,1,1,1,1,0]
+ }
+ neighbor_neighbors: {
+ flips: [0]
+ force: [0]
+ }
+ board: {
+ flips: [0]
+ force: [0]
+ }
+ }
+ 4: {
+ neighbors: {
+ flips: ['all', 4,4,4,4,4,3,3,2,2,1]
+ force: [4,3,3,3,3,3,2]
+ }
+ neighbor_neighbors: {
+ flips: [0]
+ force: [2,2,2,1,1,1,0]
+ }
+ board: {
+ flips: [0]
+ force: [0]
+ }
+ }
+ 5: {
+ neighbors: {
+ flips: ['all','all','all','all',5,5,5,4,4,4,3,3,3,2]
+ force: [6,6,6,6,5,5,5,4,4,4,3]
+ }
+ neighbor_neighbors: {
+ flips: [2,2,2,2,2,2,1,1,1,1,0]
+ force: [4,3,3,3,3,2,2,2,1]
+ }
+ board: {
+ flips: [0]
+ force: [0]
+ }
+ }
+ 6: {
+ neighbors: {
+ flips: ['all','all','all','all','all',9,9,9,9,8,8,8,7,7,7,6,6,6,5,5,5,4]
+ force: [9,9,9,9,9,8,8,8,7]
+ }
+ neighbor_neighbors: {
+ flips: [5,5,5,5,5,5,5,4,4,4,3,3,3,2,2,2,1]
+ force: [6,6,5,5,4,4,3,3,2]
+ }
+ board: {
+ flips: [0]
+ force: [0]
+ }
+ }
+ 7: {
+ neighbors: {
+ flips: ['all']
+ force: [10]
+ }
+ neighbor_neighbors: {
+ flips: ['all','all','all','all',9,8,7,6,5,4,3,2]
+ force: [10]
+ }
+ board: {
+ flips: [0]
+ force: [5,4,3,2,1]
+ }
+ }
+ lots: {
+ neighbors: {
+ flips: [0]
+ force: [0]
+ }
+ neighbor_neighbors: {
+ flips: [0]
+ force: [0]
+ }
+ board: {
+ flips: ['all']
+ force: [10]
+ }
+ }
+}
+difficulty_level = 0
+next_level_at = 200
+adjust_difficulty_level = ->
+ while score > next_level_at
+ difficulty_level += 1
+ next_level_at *= 1.4
+
+
# remove the selected tiles from the board, create new tiles, and slide everything into place
blip_selection = ->
- faders = selected.num_sort()
+ adjust_difficulty_level()
+ word_length = selected_word().length
+ faders = selected
selected = []
update_selection_display()
- for i in faders
- html_tiles[i].unbind('click').fadeOut fade_ms
- timeout fade_ms + 1, ->
- # which tiles need to be slid down
- sliders = (false for i in board)
-
- 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
+ neighbors = {}
+ nneighbors = {}
+ for tile in faders
+ tile.dom.unbind('click').fadeOut fade_ms
+ tile.new_hp = tile.hp
+ for n in tile.space.neighbors
+ neighbors[n.id] = n.tile
+ for nn in n.neighbors
+ nneighbors[nn.id] = nn.tile
+ # fix overlaps of faders, neighors, nneighbors
+ for tile in faders
+ delete nneighbors[tile.space.id]
+ delete neighbors[tile.space.id]
+ 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)
+ areas = {
+ neighbors: {
+ tiles: neighbors
+ up: []
+ down: []
+ }
+ neighbor_neighbors: {
+ tiles: nneighbors
+ up: []
+ down: []
+ }
+ board: {
+ tiles: (space.tile for space in spaces)
+ up: []
+ down: []
+ }
+ }
+ for k, v of areas
+ for t in v.tiles
+ if t.hp is 0
+ v.down.push t
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
-
- html_tiles[deleted].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]
- sliders[dest] = true
- --dest
- 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
- html_tiles[i].animate {top: "#{tile_top_px[i]}px"}, slide_ms
- sliders[i] = false
+ v.up.push t
+ if word_length < 8
+ boom = booms[word_length]
+ else
+ boom = booms.lots
+ for area_name, effects of boom
+ area = areas[area_name]
+ if difficulty_level < effects.flips.length
+ flips = effects.flips[difficulty_level]
+ else
+ flips = effects.flips.last()
+ if flips is 'all' or flips >= area.down.length
+ for t in area.down
+ unsink t
+ else
+ down_count = area.down.length
+ flips_left = flips
+ while flips_left > 0 and down_count > 0
+ flips_left -= 1
+ flipper = Math.floor(Math.random() * down_count)
+ unsink area.down[flipper]
+ down_count -= 1
+ # move the last tile back into range
+ area.down[flipper] = area.down[down_count]
+ if difficulty_level < effects.force.length
+ force = effects.force[difficulty_level]
+ else
+ force = effects.force.last()
+ if force > 0
+ for tile in area.up
+ tile.new_hp = tile.hp + force
+ for s in spaces
+ s.tile.new_hp ?= s.tile.hp - 1
+ if s.tile.new_hp < 0
+ s.tile.new_hp = 0
+ else if s.tile.new_hp > HP_MAX
+ s.tile.new_hp = HP_MAX
+ if s.tile.new_hp isnt s.tile.hp
+ s.tile.dom.removeClass "hp#{s.tile.hp}"
+ s.tile.dom.addClass "hp#{s.tile.new_hp}"
+ s.tile.hp = s.tile.new_hp
+ delete s.tile.new_hp
+ timeout fade_ms + 1, ->
+ # delete old tiles, mark where tiles are moving
+ for fader in faders
+ fader.space.column.fader_count += 1
+ fader.dom.remove()
+ fader.removed = true
+ for above in fader.space.aboves
+ if above.tile.dest?
+ above.tile.dest += 1
+ else
+ above.tile.dest = above.id + 1
+
+ # move tiles down (graphically and in data structure)
+ rspaces = []
+ for s in spaces
+ rspaces.unshift s
+ for space in rspaces
+ tile = space.tile
+ if tile.dest? and not (tile.removed?)
+ dest_space = spaces[tile.dest]
+ delete tile.dest
+ tile.dom.animate {top: "#{dest_space.top_px}px"}, slide_ms
+ tile.space = dest_space
+ dest_space.tile = tile
+
+ # create new tiles
+ for column in columns
+ dest = 0
+ while column.fader_count > 0
+ column.fader_count -= 1
+ slide_from = -10 - tile_width
+ slide_from -= (50 + tile_width) * column.fader_count
+ space = column.spaces[dest++]
+ tile = new_tile space, slide_from
+ tile.dom.animate {top: "#{space.top_px}px"}, slide_ms
+
save_game()
+score_for = (word) -> Math.round(Math.pow(1.7, word.length))
+
activate_selection = ->
word = selected_word()
if word.length < 3
+ # should only happen when trying to blip a word with the keyboard
# FIXME make this a hint
log "Too short: \"#{word}\""
return
unless is_word word
+ # should only happen when trying to blip a word with the keyboard
# 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
$('#definition').click()
@@ -368,67 +631,98 @@ show_definition = (word, type, definition, language) ->
html += ''
$definition_body.html html
-
-select_tile = (num) ->
- html_tile = html_tiles[num]
- # html_tile.css backgroundColor: tile_selected_color
- selected.push num
+connector_width = 11
+connector_radius = 5
+connector_slant = 12
+add_connector = (tile, horiz, vert) ->
+ style = {}
+ switch horiz
+ when 'left'
+ style.right = '100%'
+ when 'mid'
+ style.left = 21 - connector_radius
+ when 'right'
+ style.left = '100%'
+ switch vert
+ when 'top'
+ style.bottom = '100%'
+ when 'up'
+ style.top = 21 - connector_radius - connector_slant
+ when 'down'
+ style.top = 21 - connector_radius + connector_slant
+ when 'bot'
+ style.top = '100%'
+ tile.connector = $("
").css style
+ tile.dom.append tile.connector
+
+select_tile = (tile) ->
+ selected.push tile
+ if selected.length > 1
+ prev = selected[selected.length - 2]
+ if prev.space.top_px < tile.space.top_px
+ if prev.space.left_px < tile.space.left_px
+ add_connector tile, 'left', 'up'
+ else if prev.space.left_px is tile.space.left_px
+ add_connector tile, 'mid', 'top'
+ else
+ add_connector tile, 'right', 'up'
+ else
+ if prev.space.left_px < tile.space.left_px
+ add_connector tile, 'left', 'down'
+ else if prev.space.left_px is tile.space.left_px
+ add_connector tile, 'mid', 'bot'
+ else
+ add_connector tile, 'right', 'down'
update_selection_display()
- return
-new_tile = (num, x, y) ->
- letter = new_letter()
+new_tile = (space, y) ->
+ x = space.left_px
+ l = new_letter()
+ letter = l.letter
+ hp = l.hp
- html_tile = $("#{letter}
")
+ html_tile = $("#{letter}
")
$board.append(html_tile)
+ html_tile.show()
- html_tile.data 'tile_number', num
- board[num] = letter
- html_tiles[num] = html_tile
+ tile = {
+ text: letter
+ dom: html_tile
+ hp: hp
+ space: space
+ }
+ space.tile = tile
html_tile.click ->
- me = $(this)
- num = me.data 'tile_number'
- 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
+ return unselect_all() if tile.hp < 1
+ word = selected_word()
+ if tile in selected
+ if selected_word().length > 2 and is_word(word) and tile 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 is 1
unselect_all()
- select_tile num
-
+ else
+ unselect_all()
+ select_tile tile
+ else # clicked a non-selected tile
+ if selected.length > 0 and not (tile.space in selected.last().space.neighbors)
+ unselect_all()
+ select_tile tile
+ return tile
$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')
$board = $('#board')
# make html for board
- tile_number = 0
- for col_num in [0 .. board_cols - 1]
- for num in [0 .. board_col_heights[col_num] - 1]
- x = col_num * tile_width
- y = board_col_top_px[col_num] + num * tile_width
- new_tile tile_number, x, y
- tile_number++
+ for s in spaces
+ new_tile s, s.top_px
word_bins = []; word_bins.push(',') for [0...997]
hash_word = (word) ->
@@ -478,14 +772,14 @@ extract_wiktionary_definiton = (html) ->
# archive,codebase,data,usemap:
# href: