diff --git a/Wordless.kv b/Wordless.kv
index c38281b..82f77e2 100644
--- a/Wordless.kv
+++ b/Wordless.kv
@@ -15,23 +15,36 @@
     header: header
     seconds: 0
     displayed_seconds: 0
+    tile_collector: tile_collector
+    tile_cover: tile_cover
     orientation: 'vertical'  
+    spacing: 50,50
     Header:
         id: header
-        pos_hint: {'top': 1}
+        pos_hint: {'top': 1, 'right': 0.95}
     PlayArea:
         id: playArea
     Footer:
         id: footer
         pos_hint: {'top': 0}
+    Label:
+        id: tile_collector
+        Button:
+            id: tile_cover
+            text: ""
+            background_color: 1,0,0,1 
+            pos: -5000, -5000
+            #disabled: True
         
 <Footer>
     bubble: button
-    size_hint: 1, 0.2
-    Label:
-        size_hint: 4, 2
-        pos_hint: {'x': .35, 'y': .075}
+    search: search
+    SearchWord:
+        id: search
+        pos: root.parent.center_x - search.width / 2, -25
         text: root.parent._searchword
+        font_size: 45
+        color: [.5, .75, 1, 1]
     Bonus:      
         pos: -5000, -5000
         id: button
@@ -42,7 +55,7 @@
 <PlayArea>
     orientation: 'horizontal'
     size_hint: .9, .8
-    pos_hint: {'x': .05, 'y': .075}
+    pos_hint: {'x': .05, 'y': .065}
     
 <Header>
     word_complete: wordComplete
@@ -75,6 +88,7 @@
         id: scoreboard
     Level:
         id: level_on   
+        pos_hint: {'x': -.12}
     ProgressBar:
         pos_hint: {'x': -.05}
         id: progressBar  
@@ -85,10 +99,10 @@
     Label:
         text: 'LEVEL:'
         font_size: 20
-        color: [1, 0, 1, 1]
+        color: [.75, 0, 1, 1]
     Label:
         font_size: 25
-        color: [1, 0, 1, 1]
+        color: [.75, 0, 1, 1]
         text: str(root.parent.parent.parent.level)
 
 <GameTimer>:
@@ -132,104 +146,113 @@
     size_hint_y: .9
     
 <Tile>:
-    lscore: letter_score
+    lscore: 0
     font_size: 50
     Label:
         id: letter_score
-        text: "4"
+        text: str(root.lscore)
         font_size: 17
         color: 0,0.5,1,1
         size: 5,5
         pos: root.center_x + root.width/2 - 12, root.y + 8
         
+<ScoreDisplay@BoxLayout>
+    text1: 'test'
+    text2: ''
+    color: 0,0,0,1 
+    BoxLayout:
+        orientation: 'horizontal'
+        Label:
+            size_hint: 0.25, 1
+            pos_hint: {'right': 0.65}
+            text: root.text1
+            font_size: 30
+            color: root.color
+        Label:
+            size_hint: 0.25, 1
+            pos_hint: {'right': 0.35}
+            text: root.text2
+            font_size: 30
+            color: root.color
+        
 
 <MenuScreen>
+    scores: 0,0,0,0,0
+    player: '','','','',''
     your_score: 0
-    champ_score: 0
-    second_score: 0
-    third_score: 0
-    fourth_score: 0
-    fifth_score: 0
-    champion: ''
-    second: ''
-    third: ''
-    fourth: ''
-    fifth: ''
+    
     Button:
         color: 0,0,0,1
         on_press: root.manager.current = 'game' 
         background_color: 0.2,1,2,1
-
+       
         Label:
             text: 'Your Score:'
             font_size: 60
             color: 0,1,0.5,1
-            pos: root.center_x - 100, root.center_y + 200
+            pos: root.center_x - 110, root.center_y + 200
         Label:
             text: str(root.your_score)
             font_size: 65
             color: 0,1,0.5,1
-            pos: root.center_x + 100, root.center_y + 200
+            pos: root.center_x + 110, root.center_y + 200
         Label:
             text: 'High Scores'
-            font_size: 70
+            font_size: 80
             color: 1,0,0.2,1
-            pos: root.center_x - 80, root.center_y + 100
+            pos: root.center_x - 70, root.center_y + 100
         Label:
-            text: str(root.champion)
-            font_size: 30
+            text: str(root.player[0])
+            font_size: 35
             color: 0,0,0,1
-            pos: root.center_x -150, root.center_y + 50
+            pos: root.center_x -150, root.center_y + 35
         Label:
-            text: str(root.champ_score)
-            font_size: 30
+            text: str(root.scores[0])
+            font_size: 35
             color: 0,0,0,1
-            pos: root.center_x +50, root.center_y + 50   
+            pos: root.center_x +50, root.center_y + 35   
         Label:
-            text: str(root.second)
-            font_size: 30
+            text: str(root.player[1])
+            font_size: 35
             color: 0,0,0,1
-            pos: root.center_x -150, root.center_y + 25
+            pos: root.center_x -150, root.center_y + 5
         Label:
-            text: str(root.second_score)
-            font_size: 30
+            text: str(root.scores[1])
+            font_size: 35
             color: 0,0,0,1
-            pos: root.center_x +50, root.center_y + 25   
+            pos: root.center_x +50, root.center_y + 5   
         Label:
-            text: str(root.third)
-            font_size: 30
+            text: str(root.player[2])
+            font_size: 35
             color: 0,0,0,1
-            pos: root.center_x -150, root.center_y 
+            pos: root.center_x -150, root.center_y -25
         Label:
-            text: str(root.third_score)
-            font_size: 30
+            text: str(root.scores[2])
+            font_size: 35
             color: 0,0,0,1
-            pos: root.center_x +50, root.center_y 
+            pos: root.center_x +50, root.center_y -25
         Label:
-            text: str(root.fourth)
-            font_size: 30
+            text: str(root.player[3])
+            font_size: 35
             color: 0,0,0,1
-            pos: root.center_x -150, root.center_y - 25
+            pos: root.center_x -150, root.center_y - 55
         Label:
-            text: str(root.fourth_score)
-            font_size: 30
+            text: str(root.scores[3])
+            font_size: 35
             color: 0,0,0,1
-            pos: root.center_x +50, root.center_y  - 25  
+            pos: root.center_x +50, root.center_y  - 55 
         Label:
-            text: str(root.fifth)
-            font_size: 30
+            text: str(root.player[4])
+            font_size: 35
             color: 0,0,0,1
-            pos: root.center_x -150, root.center_y - 50
+            pos: root.center_x -150, root.center_y - 85
         Label:
-            text: str(root.fifth_score)
-            font_size: 30
+            text: str(root.scores[4])
+            font_size: 35
             color: 0,0,0,1
-            pos: root.center_x +50, root.center_y  - 50  
+            pos: root.center_x +50, root.center_y  - 85
         Label:
-            text: 'Click anywhere to begin new Game'
+            text: 'Click Anywhere to begin new Game'
             font_size: 40
-            color: 1,1,1,1
-            pos: root.center_x - 50, root.center_y - 200
-
-
-
+            color: 1,1,1,1 
+            pos: root.center_x -50, root.center_y  - 200
diff --git a/board.py b/board.py
index e9722db..886395d 100644
--- a/board.py
+++ b/board.py
@@ -1,5 +1,6 @@
 
 from kivy.uix.boxlayout import BoxLayout
+from kivy.uix.floatlayout import FloatLayout
 from kivy.uix.bubble import BubbleButton
 from kivy.uix.label import Label
 from kivy.properties import StringProperty, ObjectProperty, NumericProperty, \
@@ -7,10 +8,11 @@
 from kivy.clock import Clock
 from kivy.uix.textinput import TextInput
 from kivy.uix.screenmanager import ScreenManager, Screen, RiseInTransition
+from kivy.uix.popup import Popup 
 
 from words import Letters, Dictograph
 from collections import OrderedDict
-from tile import Tile
+from tile import Tile, SearchWord
 from graph_v2 import Graph
 import math
 
@@ -46,7 +48,7 @@ class Board(Screen):
     _dictionary = Dictograph("us_cad_dict.txt")
     _columns = []
     _game_over = False
-    _searchword = StringProperty('Search word')
+    _searchword = StringProperty('')
     play_area = ObjectProperty()
     complete = StringProperty()
     color = ListProperty()
@@ -56,14 +58,7 @@ class Board(Screen):
     level = NumericProperty(0)
     
     tiles = []
-    
-    def check_neighbors(self, tile, word):
-        neighbors = self._board.neighbours(tile)
-        for neighbor in neighbors:
-            if self._dictionary.in_trie(word + neighbor.text):
-                return True
-        return False
-    
+        
     def complete_word(self, tile):        
         # display current letters selected in sequence selected        
         
@@ -72,8 +67,7 @@ def complete_word(self, tile):
         for tile in self._highlighted:
             letter = tile.text
             word += letter
-            score = Letters.calc_add_score(word, score, letter)
-            
+            score = Letters.calc_add_score(word, score, letter)            
         
         self.value = score
         self.complete = word 
@@ -107,9 +101,9 @@ def highlight(self, tile, touch):
                     
                     # if last exists, get neighbors
                     if last:
-                        neighbours = self._board.neighbours(last)
+                        neighbours = self._board.neighbours(last.number)
                     # allow highlighting if first tile or adjacent tile
-                    if not last or tile in neighbours:                
+                    if not last or tile.number in neighbours:                
                         self._highlighted[tile] = len(self._highlighted)
                         tile.background_color = self.tile_color
             
@@ -154,17 +148,23 @@ def __init__(self, **kwargs):
         self.update_board()
         
 
-    def update_board(self):
+    def update_board(self, tiles = None):
         # rebuild tile list from rows
-        tiles = [tile for column in self._columns for tile in \
-                reversed(column.children)]
-        self.tiles = tiles
+        if tiles == None:
+            tiles = [tile for column in self._columns for tile in \
+                    reversed(column.children)]
+            self.tiles = tiles
+            # get just the numbers
+            tiles = [tile.number for tile in tiles]
+            
+            # create graph representing the board
+            self._board = Graph(set(tiles))
         # fill out edges of graph
         edges = []
         
         # check if at board boundaries
         
-        for i in range(len(tiles)):           
+        for i in tiles:        
             
             left = i % TILE_ROWS == 0
             right = i % TILE_ROWS == TILE_ROWS - 1 
@@ -183,48 +183,44 @@ def update_board(self):
             
             # not left of the board
             if not left:
-                edges.append((tiles[i], tiles[i-1]))
+                self._board.add_edge((i, i-1))
                 
             # not right of the board
             if not right:
-                edges.append((tiles[i], tiles[i+1]))
+                self._board.add_edge((i, i+1))
             
             # not top of the board
             if not top:      
                 if not right:
-                    edges.append((tiles[i], tiles[i-TILE_ROWS + 1 - offset]))  
+                    self._board.add_edge((i, i-TILE_ROWS + 1 - offset))  
                 elif not even:  # right and odd
-                    edges.append((tiles[i], tiles[i-TILE_ROWS]))            
+                    self._board.add_edge((i, i-TILE_ROWS))            
                 if not left: 
-                    edges.append((tiles[i], tiles[i-TILE_ROWS - offset]))  
+                    self._board.add_edge((i, i-TILE_ROWS - offset))  
                 elif even:  # left and even
-                    edges.append((tiles[i], tiles[i-TILE_ROWS]))         
+                    self._board.add_edge((i, i-TILE_ROWS))         
             
                 
             # not bottom of the board
             if not bottom:
                 if not right:
-                    edges.append((tiles[i], tiles[i+TILE_ROWS + 1 - offset]))
+                    self._board.add_edge((i, i+TILE_ROWS + 1 - offset))
                 elif not even:  # right and odd
-                    edges.append((tiles[i], tiles[i+TILE_ROWS]))                      
+                    self._board.add_edge((i, i+TILE_ROWS))                      
                 if not left:
-                    edges.append((tiles[i], tiles[i+TILE_ROWS - offset]))   
+                    self._board.add_edge((i, i+TILE_ROWS - offset))   
                 elif even:  # left and even
-                    edges.append((tiles[i], tiles[i+TILE_ROWS]))    
+                    self._board.add_edge((i, i+TILE_ROWS))    
         
-        # create graph representing the board
-        self._board = Graph(set(tiles), edges)
         
-        self._searchword = self._dictionary.find_longest_word(self._board)
         
     def reset_tiles(self, min_time=-float('inf')):
-        if  _Board.game_timer.seconds >= min_time:
+        if  _Board.score == 0 or (_Board.game_timer.seconds >= min_time and 
+                            not Tile.anims_to_complete):
             add = []
             for tile in self.tiles:
-                # add tiles to _highlighted for Tile.replaceTiles
-                self._highlighted[tile] = len(Board._highlighted)
                 tile.background_color = [1,.5,.5,1]
-            Tile.replace_tiles(self._columns)
+            Tile.replace_tiles(set(self.tiles), self._columns)
             self.complete = '_ _ _'
             self.value = 0
     
@@ -239,6 +235,7 @@ def on_enter(self):
             self.progress.value = 0
             self.progress.max = LEVEL_1_POINTS
             self._game_over = False
+            self.footer.search.remove()
         
         
 class MenuScreen(Screen):
@@ -272,10 +269,12 @@ def __init__(self, **kwargs):
         Clock.schedule_interval(self.update, .05)
     
     def update(self, time_passed):
+        increment = max(int(abs( self.displayed_score - _Board.score) / 50), 1)
+        
         if self.displayed_score < _Board.score:
-            self.displayed_score += 1
+            self.displayed_score += increment
         if self.displayed_score > _Board.score:
-            self.displayed_score -= 1
+            self.displayed_score -= increment
                     
         # reset score progress bar every 100 points because reached next level
         # add seconds to timer when points scored
@@ -288,6 +287,8 @@ class WordComplete(Label):
 class GameTimer(BoxLayout):
     seconds = NumericProperty()
     displayed_seconds = NumericProperty()
+    cover_timer = -1
+    next_tile_to_fall = TILE_ROWS - 1
     
     def __init__(self, **kwargs):        
         # call parent class init
@@ -297,23 +298,56 @@ def __init__(self, **kwargs):
 
     def update(self, time_passed):
         sec = math.ceil(self.seconds)
+        increment = max(int(abs(sec - self.displayed_seconds) / 50), 1)
         if self.displayed_seconds < sec:
-            self.displayed_seconds += 1
+            self.displayed_seconds += increment
                 
         elif self.displayed_seconds > sec:
-            self.displayed_seconds -= 1
+            self.displayed_seconds -= increment
         
         if _Board.level > 0:
             if self.seconds > 0:
                 if _Board.level > 1:
                     time_passed *= (_Board.level*4/9)
+                    
                 self.seconds = self.seconds - time_passed
+                #if Board.level > 
+                                            
             # don't end the game if the score bubble is still animating
             # or if tiles are falling
             elif not _Board._game_over and not _Board.footer.bubble.working\
-                and not Tile.anims_to_complete:
+                and not Tile.anims_to_complete and SearchWord.appeared != 1:
                 _Board._game_over = True
-                GameOver(_Board.score)
+                GameOver()
+                
+        
+                
+    def tile_drop(self, time_passed):
+            
+        
+        # drop the bottom tile out of a row every 20 seconds - levels
+        # but never faster than once per second
+        self.cover_timer += time_passed
+        tile = _Board.tiles[self.next_tile_to_fall]
+        drop_time = max(1, 20 - _Board.level)
+        if self.cover_timer > drop_time:
+            
+            if not Tile.anims_to_complete:
+                fall = True
+                for highlighted in _Board._highlighted:
+                    if highlighted.parent == tile.parent:
+                        fall = False
+                if fall:                 
+                    tile.background_color = [1,0,0,1]   
+                    _Board.tile_cover.size = tile.width, tile.height / 20
+                    self.cover_timer = 0
+                    Tile.replace_tiles([tile], [tile.parent])
+                    self.next_tile_to_fall += TILE_ROWS 
+                    self.next_tile_to_fall %= TILE_ROWS * TILE_COLUMNS  
+        else:        
+            _Board.tile_cover.size = tile.width, tile.height * self.cover_timer / drop_time
+            _Board.tile_cover.background_color = 1,0,0, self.cover_timer / drop_time
+            _Board.tile_cover.pos = tile.pos
     
 
 class Bonus(BubbleButton):    
@@ -328,80 +362,99 @@ def on_touch_move(self, touch):
 class Level(BoxLayout):
     pass
     
-    
-def GameOver(end_score, name = None):
+
+
+def GameOver():
     # save score to file only if higher than rest saved
-    # see if got new high score!
-    if not name:
-        name = 'winner!'
+    # see if got new high score
+    
+    try: # check that data is initialized
+        GameOver.input_text
+    except AttributeError: # initialize data
+        GameOver.input_text = None
+        GameOver.score_list = []
+        
     _Board._highlighted.clear()
-    score_list = []
-    with open('high_scores.txt', 'r') as file:
+    Clock.unschedule(_Board.game_timer.tile_drop)
+    _Board.game_timer.cover_timer = -1
+    _Board.tile_cover.pos = -5000, -5000
+    _Board.manager.transition = RiseInTransition(duration=.5)
+    _Board.manager.current = 'menu'
+    
+
+    box = BoxLayout()
+    text_in = TextInput(multiline = False, font_size = 40)
+    box.add_widget(text_in)
+
+    popup = Popup(title='NEW HIGH SCORE! Enter Your Name')
+    popup.content = box
+    popup.size_hint = (None, None)
+    popup.size=(550, 120)
+    popup.auto_dismiss = False
+
+    text_in.on_text_validate = LastScreen
+    
+    GameOver.input_text = text_in
+    GameOver.input_text.popup = popup
+    
+    
+     # high score file must end with newline
+    try:
+        file = open('high_scores.txt', 'r')
         for line in file:
             line = line.strip().split(",")
             print("line:", line)
             try:
-                score_list.append((line[0],line[1])) 
+                GameOver.score_list.append((line[0],line[1])) 
             except:
                 # if blank line do nothing
                 continue
         file.close()
+        print("DEBUG")
+    except:
+        # dummy score emtry if file was empty
+        GameOver.score_list.append((0, 'Falon'))
+  
 
-    try:
-        score_list[-1][0]
-    except IndexError:
-        # if list empty append dummy zero record
-        score_list.append((0, 'Falon'))
+    if int(GameOver.score_list[-1][0]) < _Board.score:
+        popup.open()
+    else:
+        LastScreen()
   
+    
+def LastScreen():
+    input_text = GameOver.input_text
+    score_list = GameOver.score_list
+    player = input_text.text
+       
+    end_score = _Board.score 
+    input_text.popup.dismiss()
+
+   
     if int(score_list[-1][0]) < end_score:
         # reopen file for appending this time
         file_append = open('high_scores.txt', 'a')
 
         # new high score!!!
         # PROMPT USER FOR NAME AND SAVE AS name
-        score_list.append((end_score, name))
-        
+        score_list.append((end_score, player))
         file_append.write(str(end_score))
         file_append.write(", ")
-        file_append.write(name)
+        file_append.write(player)
+        file_append.write("\n")
         file_append.close()
-    print(score_list)
    
-    Records = _Board.manager.current_screen        
-    _Board.manager.transition = RiseInTransition(duration=.5)
-    _Board.manager.current = 'menu'
-    _Board.manager.current_screen.champ_score = int(score_list[-1][0])
-    _Board.manager.current_screen.your_score = end_score
-    _Board.manager.current_screen.champion = score_list[-1][1]
-    try:
-        _Board.manager.current_screen.second_score = int(score_list[-2][0])
-        _Board.manager.current_screen.second = score_list[-2][1]
-    except:
-        _Board.manager.current_screen.second_score = 0
-        _Board.manager.current_screen.second = 'Falon'
-
-    try:
-        _Board.manager.current_screen.third_score = int(score_list[-3][0])
-        _Board.manager.current_screen.third = score_list[-3][1]
-    except:
-        _Board.manager.current_screen.third_score = 0
-        _Board.manager.current_screen.third = 'Falon'
 
-    try:
-        _Board.manager.current_screen.fourth_score = int(score_list[-4][0])
-        _Board.manager.current_screen.fourth = score_list[-4][1]
-    except:
-        _Board.manager.current_screen.fourth_score = 0
-        _Board.manager.current_screen.fourth = 'Falon'
+    Records = _Board.manager.current_screen  
 
-    try:
-        _Board.manager.current_screen.fifth_score = int(score_list[-5][0])
-        _Board.manager.current_screen.fifth = score_list[-5][1]
-    except:
-        _Board.manager.current_screen.fifth_score = 0
-        _Board.manager.current_screen.fifth = 'Falon'
 
-    
-    
-    #_Board.reset_tiles()
-    #exit()
+    Records.champ_score = int(score_list[-1][0])
+    Records.your_score = end_score
+    Records.champion = score_list[-1][1]
+    for i in range(1, len(score_list)):
+        try:
+            Records.scores[i-1] = int(score_list[-i][0])
+            Records.player[i-1] = score_list[-i][1]
+        except:
+            Records.scores[i-1] = 0
+            Records.player[i-1] = 'Falon'
diff --git a/high_scores.txt b/high_scores.txt
index 9a85e9a..4f675d9 100644
--- a/high_scores.txt
+++ b/high_scores.txt
@@ -1 +1 @@
-35, winner!
\ No newline at end of file
+213, hey
diff --git a/tile.py b/tile.py
index 97afcef..259a73f 100644
--- a/tile.py
+++ b/tile.py
@@ -1,9 +1,11 @@
 
 from random import randint, random
 from kivy.uix.button import Button
+from kivy.uix.label import Label
 from words import Letters
 from kivy.animation import Animation
-from kivy.properties import ObjectProperty
+from kivy.properties import NumericProperty
+from kivy.clock import Clock
 
 _Board = None
 
@@ -12,16 +14,13 @@ class Tile(Button):
     """    
     anims_to_complete = 0
     tiles_being_removed = 0
-    lscore = ObjectProperty()
-    number = 0
+    lscore = NumericProperty()
+    number = NumericProperty(0)
+    tiles_to_update = set()
+    intended_pos = None
     
     def __repr__(self):
-        score = ""
-        try:
-            score = self.lscore.text
-        except:
-            pass
-        return self.text + "," + score
+        return self.text + "-" + str(self.number)
     
     def __init__(self, number, board=None, **kwargs):
         """
@@ -46,8 +45,10 @@ def __init__(self, number, board=None, **kwargs):
     
         letter = Letters.letters[rand]
         self.text = letter
-        self.lscore.text = str(Letters.Value[letter])
+        self.lscore = Letters.Value[letter]
         self.number = number
+        
+        self.intended_pos = self.pos
     
     def update_color(self, instance, value):
         if self in _Board._highlighted or value == [1,1,1,1]:
@@ -72,8 +73,7 @@ def on_touch_down(self, touch):
         """      
         touch.multitouch_sim = False
         if touch.is_touch or touch.button == 'left':
-            if self.collide_point(touch.x, touch.y) \
-                and not Tile.anims_to_complete:
+            if self.collide_point(touch.x, touch.y):
                 _Board.highlight(self, touch)            
                 
                 # set grab to catch release off of tiles
@@ -100,8 +100,7 @@ def on_touch_move(self, touch):
 
         """
         if touch.is_touch or touch.button == 'left':
-            if self.collide_point(touch.x, touch.y) \
-                and not Tile.anims_to_complete: 
+            if self.collide_point(touch.x, touch.y): 
                 _Board.highlight(self, touch)
                 return True
         return False
@@ -125,7 +124,7 @@ def on_touch_up(self, touch):
         """
 
         if touch.is_touch or touch.button == 'left':
-            if touch.grab_current is self and not Tile.anims_to_complete: 
+            if touch.grab_current is self: 
                 word = _Board.complete
                 # clear word complete text
                 _Board.complete = '_ _ _'
@@ -134,7 +133,7 @@ def on_touch_up(self, touch):
                 touch.ungrab(self)
                 # only check word if on playArea
                 if _Board._dictionary.lookup(word) and \
-                    _Board.play_area.collide_point(touch.x, touch.y) \
+                    _Board.collide_point(touch.x, touch.y) \
                     and _Board._highlighted:
                         
                     
@@ -164,7 +163,8 @@ def on_touch_up(self, touch):
                     for tile in _Board._highlighted:
                         affected_columns.add(tile.parent)
             
-                    Tile.replace_tiles(affected_columns)
+                    Tile.replace_tiles(set(_Board._highlighted), affected_columns)        
+                    _Board._highlighted.clear()
                     
 
                 else:
@@ -209,37 +209,43 @@ def done_bubble(self, instance):
         # reset bubble (allow game to end)
         instance.working = 0
     
-    def replace_tiles(affected_columns):
+    def replace_tiles(tiles, affected_columns):
         # remove and replace tiles 
         for column in affected_columns:
             found = False
             i = 0
             remove = []
+            falling = []
             # count tiles removed
             for tile in column.children:
-                if tile in _Board._highlighted:
+                if tile in tiles:
                     found = True
                     remove.append(tile)
                     column.missing_tiles += 1
                 elif found:                                    
                     Tile.fall(column.children, i)
+                    falling.append(tile)
                 i += 1
             add = []
             # build animations
             for tile in remove:        
                 add.append(tile.remove())
+                
             # apply animations
             for new in add:                
                 Tile.add(new[0], new[1], new[2], new[3])
-        
-        _Board._highlighted.clear()
+                
+            # reassign falling tiles
+            for tile in falling:
+                tile.fall_assignment()
     
     def add(remove, old, add, new):
         # change the parent of the removed tiles
         column = old.parent
         column.add_widget(new, index=len(column.children))
         column.remove_widget(old)
-        _Board.footer.add_widget(old, index = 1)
+        _Board.tile_collector.add_widget(old, index = 1)
+        _Board.tiles[new.number] = new
         
         # play animations
         remove.start(old)
@@ -255,13 +261,14 @@ def remove(self):
             t='out_bounce', d = 1.5)
         
         dest_tile = column.children[len(column.children)-column.missing_tiles]
-        fall_in =  Animation(pos=(self.x, dest_tile.y), \
-            t='out_bounce', d = 1)
+        destination = (self.x, dest_tile.y)
+        fall_in =  Animation(pos=destination, t='out_bounce', d = 1)
         Tile.anims_to_complete += 1
         Tile.tiles_being_removed += 1
-        new_tile = Tile(self.number)
+        new_tile = Tile(dest_tile.number)
         new_tile.x = self.x
         new_tile.y = window.height + 100
+        new_tile.intended_pos = destination
         
         fall_out.on_complete = self.remove_complete
         fall_in.on_complete = new_tile.add_complete
@@ -277,17 +284,69 @@ def remove_complete(self, instance):
     
     def fall(tiles, i):
         tile = tiles[i]
+        column = tile.parent
         
         prev_tile = tiles[i-tile.parent.missing_tiles]
+        tile.next_number = prev_tile.number
         Tile.anims_to_complete += 1
-        animation = Animation(pos=(prev_tile.x, prev_tile.y), \
-                        t='out_bounce', d = 1)
+        destination = (prev_tile.x, prev_tile.y)
+        animation = Animation(pos=destination, t='out_bounce', d = 1)
         animation.on_complete = tile.fall_complete
+        tile.intended_pos = destination
         animation.start(tile)
+    
+    def fall_assignment(self):
+        
+        # clean up falling tile set assignment
+        if self.next_number >= 0:
+            _Board.tiles[self.next_number] = self
+            self.number = self.next_number
+            self.next_number = -1
         
     def fall_complete(self, instance):
-        Tile.anims_to_complete -= 1 
+        Tile.anims_to_complete -= 1         
         
         if not Tile.anims_to_complete:
-            # rebuild graph
-            _Board.update_board()
+            _Board.footer.search.get_next(True)
+            
+class SearchWord(Label):
+    appeared = 0
+    
+    def remove(self):
+        _Board._searchword = ''
+        self.appeared = 0
+        
+    def appear(self):
+        search = _Board.footer.search
+        animation = Animation(pos=(search.x, search.y), t='out_bounce', d = 1.5)
+        animation.on_complete = self.appear_complete
+        search.pos =  search.x, _Board.height + 200
+        
+        animation.start(search)
+        self.appeared = 1
+        
+    def appear_complete(self, instance):
+        self.appeared = 2
+        
+    def get_next(self, trigger_reset=False):        
+        if _Board.score > 0:
+            _Board._searchword = _Board._dictionary.find_longest_word \
+                                (_Board._board, _Board.tiles)
+            if trigger_reset and _Board._searchword == '':
+                _Board.reset_tiles()
+            
+            # if no search word has appeared
+            if self.appeared == 0:
+                self.appear()
+            
+            timer = _Board.game_timer
+            if _Board.level > 2 and timer.cover_timer < 0:
+                Clock.schedule_interval(timer.tile_drop, .05)
+                tile = _Board.tiles[0]
+                timer.cover_timer = 0
+                _Board.tile_cover.size = tile.width, tile.height / 20
+                 
+            
+            
+            
+            
diff --git a/words.py b/words.py
index 068a807..bc613ad 100644
--- a/words.py
+++ b/words.py
@@ -63,7 +63,7 @@ def in_trie(self, word):
                 return None
         return _END in current_dict
         
-    def find_long_word(self, graph, tile):
+    def find_long_word(self, graph, tiles, tile):
         R = dict()
         S = [(tile, tile)]
         letters = OrderedDict()
@@ -76,17 +76,17 @@ def find_long_word(self, graph, tile):
                 value = 0
                 if len(letters):
                     value = letters[next(reversed(letters))]
-                value = Letters.calc_add_score(word, value, curr.text)
-                word += curr.text
+                value = Letters.calc_add_score(word, value, tiles[curr].text)
+                word += tiles[curr].text
                 letters[curr] = value
                 valid = False
                 for n in graph.neighbours(curr):
                     if n not in letters:
-                        new_word = word + n.text
+                        new_word = word + tiles[n].text
                         # if n + curr is a word add (curr, n)
                         found = self.lookup(new_word) 
                         if found:
-                            alt = Letters.calc_add_score(word, value, n.text)
+                            alt = Letters.calc_add_score(word, value, tiles[n].text)
                             if alt > best_value:
                                 best_value = alt
                                 best = new_word
@@ -95,7 +95,7 @@ def find_long_word(self, graph, tile):
                             valid = True
                 # walk back up graph until we find an open branch
                 while S and len(letters) > 1 and not valid:
-                    R[tuple(letters)] = prev  # change to value of this word  
+                    R[tuple(letters)] = prev   
                     letters.popitem()
                     word = word[:-1]
                     curr = next(reversed(letters))
@@ -106,12 +106,12 @@ def find_long_word(self, graph, tile):
                     
         return best
         
-    def find_longest_word(self, graph):
+    def find_longest_word(self, graph, tiles):
         longest = ''
         length = 0
         longest_tile = None
         for tile in graph.vertices():
-            word = self.find_long_word(graph, tile)
+            word = self.find_long_word(graph, tiles, tile)
             if len(word) > length:
                 length = len(word)
                 longest = word
@@ -139,11 +139,13 @@ class Letters():
     def calc_add_score(word, score, letter):
         score += Letters.Value[letter]
         
-        # word length bonus of (addtional letter)*2 times the score
+        # word length bonus of (addtional letter)/2 times the score
         # for each letter over 3
         length = len(word)
-        if length > 2:
+        if 2 < length < 9:
             score += int(score/2)
+        elif length >= 9:
+            score += int(score/length-7)
             
         return score