# HexBog, a word game
# Copyright (C) 2012 Jason Woofenden
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see .
##############################################
############## settings ################
##############################################
tile_radius = 26
tile_width = tile_radius * 2
fade_ms = 400
slide_ms = 2000
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 ################
##############################################################
# so annoying that setTimeout has its arguments in the wrong order
timeout = (ms, callback) ->
setTimeout callback, ms
# warning: it's shalow (sub-elements are not cloned)
Array::clone = ->
return this.slice(0)
Array::sum = ->
ret = 0
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]
##############################################################
############## cookies (auto-save game) ################
##############################################################
set_cookie = (name, value, days) ->
date = new Date()
date.setTime date.getTime()+(days*24*60*60*1000)
cookie = "#{name}=#{value}; expires=#{date.toGMTString()}; path=/"
document.cookie = cookie
window.sc = set_cookie
get_cookie = (name) ->
key = name + '='
for c in document.cookie.split /; */
if c.indexOf key is 0
return c.substr key.length
return null
delete_cookie = (name) ->
set_cookie name, '', -1
window.dc = delete_cookie
board_cols = board_col_heights.length
board_tiles = board_col_heights.sum()
board_col_top_px = []
score = 0
tiles = new Array(board_tiles)
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
selected = []
letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
letter_distribution = [
14355 # a
3968 # b
6325 # c
7045 # d
20258 # e
2739 # f
5047 # g
4372 # h
13053 # i
516 # j
2600 # k
9631 # l
5115 # m
10082 # n
11142 # o
5292 # p
287 # qu
12341 # r
16571 # s
10215 # t
6131 # u
1728 # v
2184 # w
619 # x
3512 # y
831 # z
]
letter_distribution_total = 175973 # letter_distribution.sum()
new_letter_queue = []
new_letter = ->
if new_letter_queue.length
l = new_letter_queue.shift()
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 letter: 'Qu', hp: hp
return letter: letters[i], hp: hp
return letter: 'Z', hp: hp # just in case
# in memory it's layed out like this:
# a c f j m
# b d g k n
# e h l
# i
# for display, columns are slid vertically like so:
# f
# c j
# a g m
# d k
# b h n
# e l
# i
#
# work out which grid spaces are connected
init_board_layout = () ->
col_offset = 0
middle_col = (board_cols - 1) / 2
# how many tiles before the current tile?
for col_num in [0 .. board_cols - 1]
if col_num < middle_col
fw_other = 1
else
fw_other = -1
if col_num > middle_col
bw_other = 1
else
bw_other = -1
is_first_col = col_num is 0
is_last_col = col_num is board_cols - 1
neighbors = []
push = (offset) ->
neighbors.push col_offset + offset
col_top_px = Math.abs col_num - middle_col
col_top_px *= tile_radius
board_col_top_px.push col_top_px
above = []
for i in [0 .. board_col_heights[col_num] - 1]
is_top_tile = i is 0
is_bottom_tile = i is board_col_heights[col_num] - 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
# aboves (array of tile numbers above, starting from top)
board_aboves.push above.clone()
above.push i + col_offset
# 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
# neighbors (array of tile numbers "next to" this one)
neighbors = []
unless is_top_tile # upward link
push i - 1
unless is_bottom_tile # downward links
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]
unless is_top_tile and bw_other is -1
push i - board_col_heights[col_num - 1] + bw_other
unless is_last_col # rightward links
unless is_bottom_tile and fw_other is -1
push i + board_col_heights[col_num]
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]
# 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
if encoded? and encoded.charAt 0 is '#'
encoded = encoded.substr 1
unless encoded? and encoded.length > board_tiles
encoded = get_cookie 'hexbog'
if encoded? and encoded.length > board_tiles
load_game encoded
# work out which grid spaces are connected
# (neighbors, above, down)
init_board_layout()
$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()
$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
classes = ['selected_word', 'selected']
if is_word word
c = 0
else
c = 1
for num in selected
tiles[num].dom.addClass classes[c]
tiles[num].dom.removeClass classes[1 - c]
# unselects the last tile of the selecetion
unselect_tile = ->
_unselect_tile()
update_selection_display()
_unselect_tile = ->
num = selected.pop()
html_tile = tiles[num].dom
html_tile.removeClass 'selected_word'
html_tile.removeClass 'selected'
unselect_all = ->
while selected.length
_unselect_tile()
update_selection_display()
selected_word = ->
word = ''
word += tiles[i].text for i in selected
return word.toLowerCase()
save_charset = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQR'
char_a = "a".charCodeAt(0)
save_game = ->
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 = ->
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 = []
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
tiles[dest] = tiles[above]
tiles[dest].id = dest
tiles[dest].dom.data 'tile_number', dest
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
tiles[i].dom.animate {top: "#{tile_top_px[i]}px"}, slide_ms
sliders[i] = false
save_game()
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 = 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()
show_definition = (word, type, definition, language) ->
html = ""
html += "#{word.substr(0, 1).toUpperCase() + word.substr(1)}, #{type}"
if language isnt 'English'
html += " (#{language})"
html += ': '
html += definition
html += '
'
$definition_body.html html
select_tile = (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) ->
l = new_letter()
letter = l.letter
hp = l.hp
html_tile = $("
#{letter}
")
$board.append(html_tile)
html_tile.data 'tile_number', num
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
if selected_word().length > 2 and num is selected.last()
activate_selection()
else
if selected.length > 1
unselect_all()
select_tile num
else
unselect_all()
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
init_html_board = ->
$('#loading').remove()
$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++
word_bins = []; word_bins.push(',') for [0...997]
hash_word = (word) ->
h = 0
for i in [0...word.length]
h ^= word.charCodeAt(i) << ((i*3) % 21)
return h % 997
is_word = (str) ->
word_bins[hash_word str].indexOf(",#{str},") > -1
# this is called automatically by the compressed wordlist
parse_word_list = (compressed) ->
prefix = ''
cap_a = "A".charCodeAt 0
i = 0
next_chunk = ->
chunk = compressed[i]
for word in chunk.match(/[a-z]*[A-Z]/g)
# the capital letter (at the end of the match) says how many characters
# from the end of the previous word should be removed to create the prefix
# for the next word. "A" for 0, "B" for 1, "C" for 2, etc
bs = word[word.length - 1].charCodeAt(0) - cap_a
word = prefix + word[0 ... word.length - 1]
word_bins[hash_word word] += word + ','
prefix = word[0 ... word.length - bs]
if ++i is compressed.length
return
else
timeout 1, next_chunk
timeout 1, next_chunk
extract_wiktionary_definiton = (html) ->
found = false
finds = {}
language = false
part = false
# clean HTML
##################
# when we instantiate the html so we can use dom traversal, the browser
# will start loading images and such. This section attempts to mangle the
# html so no resources are loaded when the html is parsed.
# attributes
# src: ,