#   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 <http://www.gnu.org/licenses/>.

##############################################
##############    settings    ################
##############################################

tile_radius = 26
tile_width = tile_radius * 2

fade_ms = 400
slide_ms = 2000

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    ################
##############################################################

# 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

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


num_spaces = 0
num_spaces += column.height for column in columns
score = 0
spaces = new Array(num_spaces)

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_num = (columns.length - 1) / 2

	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_num
			bw_other = 1
		else
			bw_other = -1

		is_first_col = col_num is 0
		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_num
		col_top_px *= tile_radius

		above = []
		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 column.height - 1

			# link tile number to pixel "top" and "left" of containing column
			space.top_px = col_top_px + i * tile_width
			space.left_px = col_num * tile_width

			# aboves: array of spaces, top to bottom
			space.aboves = above.clone()
			above.push space

			# below: SINGLE tile below
			unless is_top_tile
				spaces[space.id - 1].below = space

			# 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 - columns[col_num - 1].height
				unless is_top_tile and bw_other is -1
					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 + columns[col_num].height
				unless is_top_tile and fw_other is -1
					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 > num_spaces
		encoded = get_cookie 'hexbog'
	if encoded? and encoded.length > num_spaces
		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 "<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
		classes = ['selected_word', 'selected']
		if is_word word
			c = 0
		else
			c = 1
		for tile in selected
			tile.dom.addClass classes[c]
			tile.dom.removeClass classes[1 - c]

# unselects the last tile of the selecetion
unselect_tile = ->
	_unselect_tile()
	update_selection_display()

_unselect_tile = ->
	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()

selected_word = ->
	word = ''
	word += tile.text for tile in selected
	return word.toLowerCase()

save_charset = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQR'
char_a = "a".charCodeAt(0)
save_game = ->
	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 = ->
	adjust_difficulty_level()
	word_length = selected_word().length
	faders = selected
	selected = []
	update_selection_display()
	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
				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
				if tile.new_hp
					# for overlap of board and [n]neigbors
					tile.new_hp += force
				else
					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 = score_for word
	score += word_score
	$score_display.html score
	# FIXME make some kind of animation showing score gain
	blip_selection()
	look_up_definition word
	$('#definition').click()


show_definition = (word, type, definition, language) ->
	html = "<a href=\"http://en.wiktionary.org/wiki/#{word}\" target=\"_blank\">"
	html += "#{word.substr(0, 1).toUpperCase() + word.substr(1)}</a>, #{type}"
	if language isnt 'English'
		html += " (#{language})"
	html += ': '
	html += definition
	html += '<div id="definition_credit">Definition &copy;<a href="http://en.wiktionary.org/" target="_blank">wiktionary.org</a> CC-BY-SA</div>'
	$definition_body.html html

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 = $("<div class=\"connector\"></div>").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()

new_tile = (space, y) ->
	x = space.left_px
	l = new_letter()
	letter = l.letter
	hp = l.hp

	html_tile = $("<div class=\"tile hp#{hp}\" style=\"left: #{x}px; top: #{y}px\" unselectable=\"on\">#{letter}</div>")
	$board.append(html_tile)
	html_tile.show()

	tile = {
		text: letter
		dom: html_tile
		hp: hp
		space: space
	}
	space.tile = tile

	html_tile.click ->
		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
				if selected.length is 1
					unselect_all()
				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
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
	for s in spaces
		new_tile s, s.top_px

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: <img>, <audio>, etc
	#                         onload: only <body>?
	#   archive,codebase,data,usemap: <object>
	#                           href: <link>
	#                 id,class,style: background: url(foo.png), etc
	html = html.replace /[ ]?[a-z]+=['"][^"']*['"]/ig, '', html
	html = html.replace /<\/?(audio|source|a|span|table|tr|td|table)>/ig, '', html
	html = html.replace /\[edit\]/ig, '', html

	elements = $(html)

	valid_parts = ["Abbreviation", "Adjective", "Adverb", "Article", "Cardinal number", "Conjunction", "Determiner", "Interjection", "Noun", "Numeral", "Particle", "Preposition", "Pronoun", "Verb"]

	elements.each (i, el) ->
		#which tag: el.tagName
		if el.tagName is 'H2'
			# if we found a definition in the previous language section, run with it
			# (we only stop for verbs, in hopes of finding one in english)
			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()
		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()
			for p in valid_parts
				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" 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'
					else
						key = 'nonverb'
				finds[key] ?= [part, new_def, language]
				found = true
				if part is 'verb'
					# verbs are the best! stop scanning when we find one
					return false # break
			if found.verb
				return false # break

	part_defs = (finds[i] for i in ['verb', 'nonverb', 'lame'] when finds[i])
	unless part_defs.length
		return false

	return part_defs[0]


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
		dataType: 'jsonp'
		cache: true
		success: (data, error_msg, xhr) ->
			if data?.parse?.text?['*']?
				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
				$definition_body.html "Sorry, couldn't find a definition for \"#{word}\"."
	})

start_over = ->
	selected = []
	score = 0
	difficulty_level = 0
	next_level_at = 200
	$score_display.html score
	for s in spaces
		selected.push s.tile
	blip_selection()

init_start_over_link = ->
	$('#start-over').click (event) ->
		event.preventDefault()
		if confirm "Are you sure you want to start over? There is no undo."
			start_over()

cur_tab = 'instructions'
tabtab_height = 20
tab_height = 150
init_tab = (t) ->
	$('#' + t).click ->
		return if t is cur_tab
		$('#' + cur_tab).removeClass('selected-tab').addClass('tab').animate({height: tabtab_height}, 1000)
		$('#' + t).removeClass('tab').addClass('selected-tab').animate({height: tab_height}, 1000)
		cur_tab = t
init_tabs = ->
	for t in ['instructions', 'definition', 'donate', 'restart']
		init_tab t

init_keybinding = ->
	$(window).keydown (e) ->
		switch e.keyCode
			when 32, 10, 13
				activate_selection()
			when 27
				unselect_all()

log = (args...) ->
	console.log args... if console?.log?

init_game = ->
	if $(window).height() >= 440
		$('#centerer').css('margin-top', '25px')
	init_keybinding()
	init_tabs()
	init_board()
	init_html_board()
	init_start_over_link()
	update_selection_display()

$(init_game)