Changed util load_image to no longer look in seperate folder for images. Further updates to tower efficiency, also added stats to reflect how well the player did.

35 files changed, 691 insertions, 16 deletions

diff --git a/TowerBackground2.bmp b/TowerBackground2.bmp
new file mode 100644
index 0000000..fdaf3e8
--- /dev/null
+++ b/TowerBackground2.bmp
diff --git a/TowerWindow.bmp b/TowerWindow.bmp
new file mode 100644
index 0000000..8e015c5
--- /dev/null
+++ b/TowerWindow.bmp
diff --git a/WallTile.bmp b/WallTile.bmp
new file mode 100644
index 0000000..a93ba50
--- /dev/null
+++ b/WallTile.bmp
diff --git a/brick_wall_bg.bmp b/brick_wall_bg.bmp
new file mode 100644
index 0000000..17c442a
--- /dev/null
+++ b/brick_wall_bg.bmp
diff --git a/bridge_bg_2.bmp b/bridge_bg_2.bmp
new file mode 100644
index 0000000..cbfd7bd
--- /dev/null
+++ b/bridge_bg_2.bmp
diff --git a/bridge_controls_3.bmp b/bridge_controls_3.bmp
new file mode 100644
index 0000000..53ab1cc
--- /dev/null
+++ b/bridge_controls_3.bmp
diff --git a/bridge_piece3 - Copy.bmp b/bridge_piece3 - Copy.bmp
new file mode 100644
index 0000000..68989fb
--- /dev/null
+++ b/bridge_piece3 - Copy.bmp
diff --git a/bridge_piece3.bmp b/bridge_piece3.bmp
new file mode 100644
index 0000000..6ad7793
--- /dev/null
+++ b/bridge_piece3.bmp
diff --git a/fork.bmp b/fork.bmp
new file mode 100644
index 0000000..91cc32a
--- /dev/null
+++ b/fork.bmp
diff --git a/grass.bmp b/grass.bmp
new file mode 100644
index 0000000..d07dff1
--- /dev/null
+++ b/grass.bmp
diff --git a/horrid_door.bmp b/horrid_door.bmp
new file mode 100644
index 0000000..7b91b23
--- /dev/null
+++ b/horrid_door.bmp
diff --git a/house2_map.bmp b/house2_map.bmp
new file mode 100644
index 0000000..dca52b7
--- /dev/null
+++ b/house2_map.bmp
diff --git a/house_map.bmp b/house_map.bmp
new file mode 100644
index 0000000..31797be
--- /dev/null
+++ b/house_map.bmp
diff --git a/lake_bg.bmp b/lake_bg.bmp
new file mode 100644
index 0000000..dfe037d
--- /dev/null
+++ b/lake_bg.bmp
diff --git a/map.bmp b/map.bmp
new file mode 100644
index 0000000..1a65b39
--- /dev/null
+++ b/map.bmp
diff --git a/map_foreground2.bmp b/map_foreground2.bmp
new file mode 100644
index 0000000..005adc5
--- /dev/null
+++ b/map_foreground2.bmp
diff --git a/numberPlate.bmp b/numberPlate.bmp
new file mode 100644
index 0000000..7c91d4e
--- /dev/null
+++ b/numberPlate.bmp
diff --git a/parchment.bmp b/parchment.bmp
new file mode 100644
index 0000000..2b72149
--- /dev/null
+++ b/parchment.bmp
diff --git a/sky.jpg b/sky.jpg
new file mode 100644
index 0000000..37d7c6b
--- /dev/null
+++ b/sky.jpg
diff --git a/start.py b/start.py
index dfd9cac..5a29645 100644..100755
--- a/start.py
+++ b/start.py
@@ -1,10 +1,6 @@
-import tower, levelone, leveltwo, levelthree, levelfour, util

+import tower

 

 def main():

-    levelone.run()

-    levelfour.run()

-    leveltwo.run()

-    levelthree.run()

     tower.run()

     

-if __name__ == '__main__': main()

+if __name__ == '__main__': main()
\ No newline at end of file
diff --git a/stonehedge_map.bmp b/stonehedge_map.bmp
new file mode 100644
index 0000000..35d1dd5
--- /dev/null
+++ b/stonehedge_map.bmp
diff --git a/tower.py b/tower.py
index a08bbac..c209367 100755
--- a/tower.py
+++ b/tower.py
@@ -1,4 +1,4 @@
-import random, os.path

+import random, os.path, time

 import util

 

 import pygame

@@ -358,9 +358,13 @@ def run():
     shownGap1, shownGap2 = None, None   #Variables will represent gaps that will be displayed (if they get hit or stepped on)

     fallWait, topHoleWait = 0, 0    #Variables representing timers for if the hero is falling or a gap is being displayed because it was stepped on

     

+    gapFails = 0

+    

     run = 1 #Variable representing if the game is running

     runCounter = 0 #The number of run loops the game has gone through

     

+    startTime = time.clock()

+    

     #The main game loop of the program

     while run:

         runCounter = runCounter+1

@@ -444,6 +448,8 @@ def run():
         if hero.collidelist(impassableGaps) != -1:

             fallWait = 60   #Sets the variable representing the fact that the hero is falling, because they went the wrong way

             shownGap1 = impassableGaps[hero.collidelist(impassableGaps)]

+            gapFails = gapFails + 1

+            print "Falling! (#%d)"%(gapFails)

             

         #checks if the hero is standing on top of a gap they cannot pass through    

         tempHero = hero.inflate(-70,0)

@@ -476,8 +482,8 @@ def run():
             updateRects.append(shownGap2)

         

         #Code which spawns a drop which contains a number, only called every 100 loops

-        if runCounter%75 == 0:

-            newDrop = generateDropNumber(heroNumber,levelNum)

+        if runCounter%100 == 0:

+            newDrop = generateDropNumber(heroNumber,levelNum,dropValues)

             dropRects.append(pygame.Rect(random.randint(150,850),0,50,50))

             dropValues.append(newDrop[0:2])

             dropStrings.append(newDrop[2])

@@ -547,7 +553,12 @@ def run():
         if hero.topleft[1] <= -80:

                 levelNum = levelNum+1

                 if levelNum == 8:   #Made it to the top of the tower!

-                    victoryCinematic(screen)

+                    #victoryCinematic(screen)

+                    timeTaken = int(time.clock() - startTime)

+                    minutesTaken = timeTaken/60

+                    secondsTaken = timeTaken%60

+                    topString = "You have reached the top!\nTime Taken: %dm %ds\nFails: %d"%(minutesTaken,secondsTaken,gapFails)

+                    util.ok_box(topString, (450,400), 300, 50, screen)

                     break

                     

                 #Copy copies the second floor displayed on the screen so it can be shown as the very bottom on the next level 

@@ -581,8 +592,8 @@ def run():
                 background.blit(copy, (100,850))

                 print "Now on level %d."%(levelNum)

                 

-        print clock

-        clock.tick(30) #limits to 40 FPS

+        #print clock

+        clock.tick(35) #limits to 40 FPS

 	

     

 def main():

@@ -626,9 +637,23 @@ def victoryCinematic(screen):
     

     util.ok_box("You have reached the top of the tower!", (450,400), 300, 50, screen)

     

-def generateDropNumber(heroNumber,level):

+def generateDropNumber(heroNumber,level,currentValues):

     #Randomly selects if the drop will have addition, subtraction, multiplication, or division, addition and subtraction being more likely

-    type = random.sample([0,0,0,0,0,0,1,1,1,1,1,1],1)[0]

+    

+    #Only need to check the last 2 that dropped

+    currentValues = currentValues[len(currentValues)-2:]

+    

+    type = random.sample([0,1],1)[0]

+

+    #Checks the previous entries to make sure we don't have the same type of operation more then twice

+    #As it is randomly generated, having +, +, +, +... etc over and over would not work well

+    if len(currentValues) == 2:

+        if currentValues[0][0] == currentValues[1][0]:

+            if currentValues[0][0] == 1:

+                type = 0

+            else:

+                type = 1

+                

     levelAverage = (levelRanges[level][0]+levelRanges[level][1])/2    

     returnString = ""

     if type == 0: #Addition drop

@@ -651,4 +676,4 @@ def generateDropNumber(heroNumber,level):
     return (type,number,returnString)

     

 #runs main if called via other naming convention

-if __name__ == '__main__': main()
+if __name__ == '__main__': main()
\ No newline at end of file
diff --git a/tower.pyc b/tower.pyc
new file mode 100755
index 0000000..b6725de
--- /dev/null
+++ b/tower.pyc
diff --git a/tower.py~ b/tower.py~
new file mode 100644
index 0000000..33bf43c
--- /dev/null
+++ b/tower.py~
@@ -0,0 +1,654 @@
+import random, os.path

+import util

+

+import pygame

+import pygame.font

+from pygame.locals import *

+

+#Global variables:

+

+#List representing the range of the numbers that are in the gaps on each level, the first level has numbers from 0~20 and so on

+levelRanges = [(0,20),(10,30),(20,40),(30,50),(45,65),(60,80),(65,85),(80,100)]

+

+#Generates a tower "floor", given the amount of holes in the floor and the height on the screen it will be placed on

+#Returns a list of 4 things each representing different aspects of the floor:

+#   1. A list of the rectangles which make up the "walls" of the floor"

+#   2. A list of the rectangles which represent the gaps between the floor walls

+#   3. A list of the rectangles which will contain the numbers (all within the walls, on either side of the gaps)

+#   4. A list representing which number boxes are associated with each gap

+

+def generateFloor(holes, height, type = 1):

+    walls, gaps = [], []

+    numBoxes = []

+    rect = []

+    gapPattern = []

+    if holes == 1:

+        holeSize = random.randint(10,50)*10

+        holeStart = random.randint(0,70-holeSize/10)*10

+        

+        walls.append(pygame.Rect(150,height,100+holeStart,50))

+        walls.append(pygame.Rect(250+holeStart+holeSize,height,800-holeStart-holeSize,50))

+        

+        gaps.append(pygame.Rect(250+holeStart, height, holeSize, 20))

+        

+        numBoxes.append(pygame.Rect(155+holeStart, height+5, 90, 40))

+        numBoxes.append(pygame.Rect(255+holeStart+holeSize,height+5,90,40))

+        

+        gapPattern = [(0,1)]

+        

+    elif holes == 2 and type == 1:

+    

+        hole1Size = random.randint(10,24)*10

+        hole2Size = random.randint(10,24)*10

+        centerSize = random.randint(22,70-hole1Size/10-hole2Size/10)*10

+        holeStart = random.randint(0,70-hole1Size/10-hole2Size/10-centerSize/10)*10

+        

+        #print "Hole 1 Size:%d\nHole 2 Size: %d\n Center Size: %d\nHole Start: %d"%(hole1Size,hole2Size,centerSize,holeStart)

+        

+        walls.append(pygame.Rect(150,height,100+holeStart,50))

+        walls.append(pygame.Rect(250+holeStart+hole1Size,height,centerSize,50))

+        walls.append(pygame.Rect(250+holeStart+hole1Size+centerSize+hole2Size,height,800-(holeStart+hole1Size+centerSize+hole2Size),50))

+        

+        gaps.append(pygame.Rect(250+holeStart,height,hole1Size,20))

+        gaps.append(pygame.Rect(250+holeStart+hole1Size+centerSize,height,hole2Size,20))

+        

+        numBoxes.append(pygame.Rect(155+holeStart,height+5,90,40))

+        numBoxes.append(pygame.Rect(255+holeStart+hole1Size,height+5,90,40))

+        numBoxes.append(pygame.Rect(155+holeStart+hole1Size+centerSize,height+5,90,40))

+        numBoxes.append(pygame.Rect(255+holeStart+hole1Size+centerSize+hole2Size,height+5,90,40))

+        

+        gapPattern = [(0,1),(2,3)]

+        

+    elif holes == 2 and type != 1:

+        #Randomly assigns hole sizes

+        hole1Size = random.randint(10,50)*10

+        hole2Size = random.randint(10,60-(hole1Size/10))*10

+        holeStart = random.randint(0,60-(hole1Size+hole2Size)/10)*10

+        

+        walls.append(pygame.Rect(150,height,100+holeStart,50))

+        walls.append(pygame.Rect(250+holeStart+hole1Size,height,100,50))

+        walls.append(pygame.Rect(350+holeStart+hole1Size+hole2Size,height,700-holeStart-hole1Size-hole2Size,50))

+        

+        gaps.append(pygame.Rect(250+holeStart, height, hole1Size, 20))

+        gaps.append(pygame.Rect(350+holeStart+hole1Size, height, hole2Size, 20))

+        

+        numBoxes.append(pygame.Rect(155+holeStart,height+5,90,40))

+        numBoxes.append(pygame.Rect(255+holeStart+hole1Size,height+5,90,40))

+        numBoxes.append(pygame.Rect(355+holeStart+hole1Size+hole2Size,height+5,90,40))

+        

+        gapPattern = [(0,1),(1,2)]

+

+    elif holes == 3 and type == 1:

+        holeStart = random.randint(0,2)*10

+        hole1Size = random.randint(0,1)*10

+        hole2Size = random.randint(0,2)*10

+        hole3Size = random.randint(0,1)*10

+        centerSize = random.randint(0,3)*10

+        

+        if random.randint(0,1) == 1:

+            walls.append(pygame.Rect(150,height,100+holeStart,50))

+            walls.append(pygame.Rect(350+holeStart+hole1Size,height,210+centerSize,50))

+            walls.append(pygame.Rect(660+holeStart+hole1Size+centerSize+hole2Size,height,100,50))

+            walls.append(pygame.Rect(860+holeStart+hole1Size+centerSize+hole2Size+hole3Size,height,190-(holeStart+hole1Size+centerSize+hole2Size+hole3Size),50))

+        

+            gaps.append(pygame.Rect(250+holeStart,height,100+hole1Size,20))

+            gaps.append(pygame.Rect(560+holeStart+hole1Size+centerSize,height,100+hole2Size,20))

+            gaps.append(pygame.Rect(760+holeStart+hole1Size+centerSize+hole2Size,height,100+hole3Size,20))

+        

+            numBoxes.append(pygame.Rect(155+holeStart,height+5,90,40))

+            numBoxes.append(pygame.Rect(355+holeStart+hole1Size,height+5,90,40))

+            numBoxes.append(pygame.Rect(465+holeStart+hole1Size+centerSize,height+5,90,40))

+            numBoxes.append(pygame.Rect(665+holeStart+hole1Size+centerSize+hole2Size,height+5,90,40))

+            numBoxes.append(pygame.Rect(865+holeStart+hole1Size+centerSize+hole2Size+hole3Size,height+5,90,40))

+        

+            gapPattern = [(0,1),(2,3),(3,4)]

+    

+        else:

+            walls.append(pygame.Rect(150,height,100+holeStart,50))

+            walls.append(pygame.Rect(350+holeStart+hole1Size,height,100,50))

+            walls.append(pygame.Rect(550+holeStart+hole1Size+hole2Size,height,210+centerSize,50))

+            walls.append(pygame.Rect(860+holeStart+hole1Size+centerSize+hole2Size+hole3Size,height,190-(holeStart+hole1Size+centerSize+hole2Size+hole3Size),50))

+        

+            gaps.append(pygame.Rect(250+holeStart,height,100+hole1Size,20))

+            gaps.append(pygame.Rect(450+holeStart+hole1Size,height,100+hole2Size,20))

+            gaps.append(pygame.Rect(760+holeStart+hole1Size+centerSize+hole2Size,height,100+hole3Size,20))

+        

+            numBoxes.append(pygame.Rect(155+holeStart,height+5,90,40))

+            numBoxes.append(pygame.Rect(355+holeStart+hole1Size,height+5,90,40))

+            numBoxes.append(pygame.Rect(555+holeStart+hole1Size+hole2Size,height+5,90,40))

+            numBoxes.append(pygame.Rect(665+holeStart+hole1Size+centerSize+hole2Size,height+5,90,40))

+            numBoxes.append(pygame.Rect(865+holeStart+hole1Size+centerSize+hole2Size+hole3Size,height+5,90,40))

+            

+            gapPattern = [(0,1),(1,2),(3,4)]

+            

+    elif holes == 3 and type != 1:

+    

+        holeStart = random.randint(0,10)*10

+        hole1Size = random.randint(0,15-holeStart/10)*10

+        hole2Size = random.randint(0,17-(holeStart+hole1Size)/10)*10

+        hole3Size = random.randint(0,20-(holeStart+hole1Size+hole2Size)/10)*10

+        

+        walls.append(pygame.Rect(150,height,100+holeStart,50))

+        walls.append(pygame.Rect(350+holeStart+hole1Size,height,100,50))

+        walls.append(pygame.Rect(550+holeStart+hole1Size+hole2Size,height,100,50))

+        walls.append(pygame.Rect(750+holeStart+hole1Size+hole2Size+hole3Size,height,300-(holeStart+hole1Size+hole2Size+hole3Size),50))

+        

+        gaps.append(pygame.Rect(250+holeStart,height,100+hole1Size,20))

+        gaps.append(pygame.Rect(450+holeStart+hole1Size,height,100+hole2Size,20))

+        gaps.append(pygame.Rect(650+holeStart+hole1Size+hole2Size,height,100+hole3Size,20))

+        

+        numBoxes.append(pygame.Rect(155+holeStart,height+5,90,40))

+        numBoxes.append(pygame.Rect(355+holeStart+hole1Size,height+5,90,40))

+        numBoxes.append(pygame.Rect(555+holeStart+hole1Size+hole2Size,height+5,90,40))

+        numBoxes.append(pygame.Rect(755+holeStart+hole1Size+hole2Size+hole3Size,height+5,90,40))

+        

+        gapPattern = [(0,1),(1,2),(2,3)]

+        

+    elif holes == 4:

+        walls.append(pygame.Rect(150,height,100,50))

+        walls.append(pygame.Rect(350,height,100,50))

+        walls.append(pygame.Rect(550,height,100,50))

+        walls.append(pygame.Rect(750,height,100,50))

+        walls.append(pygame.Rect(950,height,100,50))

+        

+        gaps.append(pygame.Rect(250,height,100,20))

+        gaps.append(pygame.Rect(450,height,100,20))

+        gaps.append(pygame.Rect(650,height,100,20))

+        gaps.append(pygame.Rect(850,height,100,20))

+        

+        numBoxes.append(pygame.Rect(155,height+5,90,40))

+        numBoxes.append(pygame.Rect(355,height+5,90,40))

+        numBoxes.append(pygame.Rect(555,height+5,90,40))

+        numBoxes.append(pygame.Rect(755,height+5,90,40))

+        numBoxes.append(pygame.Rect(955,height+5,90,40))

+        

+        gapPattern = [(0,1),(1,2),(2,3),(3,4)]

+        

+    return (walls, gaps, numBoxes, gapPattern)

+

+    

+    

+def generateScreen(background, levelNum):

+    

+    #defines the locations of the outer walls 

+    leftWall = pygame.Rect(100,0,50,900)

+    rightWall = pygame.Rect(1050,0,50,900)

+    bottomWall = pygame.Rect(100,850,1000,50)

+       

+    #loads up the sky graphic, selects a random portion

+    skyGraphic = util.load_image('sky.jpg')

+    background.blit(skyGraphic,(0,0),(random.randint(0,600),0,100,900))

+    background.blit(skyGraphic,(1100,0),(random.randint(0,600),0,100,900))

+    

+    if levelNum == 0:#only draw grass on the bottom level!

+        grass = util.load_image('grass.bmp')

+        background.blit(grass,(0,850))

+        background.blit(grass,(1100,850))        

+    

+    #Generates/saves the two middle floors of the tower

+    if levelNum == 0:

+        floor1size = random.sample([1,1,2,2,2,2,2],1)[0]

+        floor2size = random.sample([1,2,2,2,2,2,3,3,3,3,4],1)[0]

+        floor1type = random.randint(0,1)

+        floor2type = random.randint(0,1)

+    

+    else:        

+        floor1size = random.sample([1,2,2,2,2,2,3,3,3,3,3,4,4],1)[0]

+        floor2size = random.sample([1,2,2,2,2,2,3,3,3,3,3,4,4],1)[0]

+        floor1type = random.randint(0,1)

+        floor2type = random.randint(0,1)

+        

+    floor1 = generateFloor(floor1size,500,floor1type)

+    floor2 = generateFloor(floor2size,150,floor2type)

+    

+    floor1Numbers = len(floor1[2])

+    

+    centerWalls = util.merge(floor1[0],floor2[0])

+    gaps = util.merge(floor1[1],floor2[1])

+    numbers = util.merge(floor1[2],floor2[2])

+    

+    gapPattern = floor1[3]

+    

+    for pair in floor2[3]:

+        gapPattern.append((pair[0]+floor1Numbers, pair[1]+floor1Numbers))

+        

+    floorNumbers = []

+    gapNumbers = []

+    

+    #Goes through every number box (around each gap), and randomly assigns a number to it, based on the number range of the current level

+    for i in range(len(numbers)):

+        floorNumbers.append(random.randint(levelRanges[levelNum][0],levelRanges[levelNum][1]))

+    

+    walls = [leftWall, rightWall, bottomWall]

+    walls = util.merge(walls,centerWalls)

+    

+    #Loads the two background image files into surfaces

+    towerWallTile = util.load_image('WallTile.bmp')

+    windowTile = util.load_image('TowerWindow.bmp')

+    

+    #Prints each wall tile

+    for i in range(18):

+        for j in range(18):

+            background.blit(towerWallTile, (150+50*i,50*j))

+    

+    #Draws the four windows on the screen

+    background.blit(windowTile, (400,300))

+    background.blit(windowTile, (750,300))

+    background.blit(windowTile, (400,650))

+    background.blit(windowTile, (750,650))

+    

+    #loads the image for the walls

+    wallSprite = util.load_image('wall.bmp')

+    

+    #Draws the walls

+    for wall in walls:

+        pygame.draw.rect(background, [100,100,100], wall)

+        if wall.width == 50:    #draws the vertical walls

+            x = wall.topleft[0]

+            y = wall.topleft[1]

+            while y < wall.height:

+                background.blit(wallSprite, (x,y))

+                y = y + 50

+        else:                   #draws the horizontal walls

+            x = wall.topleft[0]

+            y = wall.topleft[1]

+            #Checks if the horizontal wall touches the right one, if so adds a small bit of tile first, to make sure it tiles properly on the right side

+            if wall.topright[0] == 1050:

+                if wall.width%50 != 0:

+                    background.blit(wallSprite,(x,y),pygame.Rect(50-(wall.width%50),0,wall.width%50,50))

+                    x = x + wall.width % 50

+            while x < wall.topright[0]:

+                background.blit(wallSprite, (x,y))

+                x = x + 50

+                if wall.topright[0] - x < 50:         

+                    background.blit(wallSprite,(x,y),pygame.Rect(0,0,wall.topright[0] - x,50))

+                    x = wall.topright[0]

+

+

+    #Goes through every gap and associates the numbers with it, also checks the randomized numbers to make sure they are passable, if not generates a new one

+    index = 0

+    for gap in gaps:

+        #makes sure there is a difference of at least two around each gap so there is room to go through

+        while -1 <= floorNumbers[gapPattern[index][0]] - floorNumbers[gapPattern[index][1]] <= 1:

+            floorNumbers[gapPattern[index][1]] = random.randint(levelRanges[levelNum][0],levelRanges[levelNum][1])    

+        gapNumbers.append((floorNumbers[gapPattern[index][0]],floorNumbers[gapPattern[index][1]]))

+        index = index+1 

+    

+    index = 0

+    numberPlate = util.load_image('numberPlate.bmp')    #The background image behind the numbers

+    

+    #Draws all the numbers/its background image around every gap

+    for numBox in numbers:

+        numberText = stringFactor(floorNumbers[index])

+        

+        #Sets up the font  which will be used in the box containing the number

+        fontSize = 40

+        font = pygame.font.Font(None, fontSize)

+        

+        displayBox = font.render(numberText, 1, (50,50,50))

+        textSize = font.size(numberText)

+        

+        background.blit(numberPlate, numBox.topleft)

+        background.blit(displayBox, (numBox.topleft[0]+(90-textSize[0])/2,numBox.topleft[1]+(40-textSize[1])/2))

+        

+        index = index+1

+    

+    background.convert()

+    return (background,walls,gaps,gapNumbers)

+    

+def run():

+    #Must initialize pygame before doing anything else

+    pygame.init()

+    random.seed()

+    

+    display_flags = DOUBLEBUF

+    

+    #XO laptop is 1200x900 resolution

+    width, height = 1200, 900

+

+    if pygame.display.mode_ok((width, height), display_flags ):

+        screen = pygame.display.set_mode((width, height), display_flags)

+		

+    #display background

+    background = pygame.Surface(screen.get_size())

+    background = background.convert()

+    background.fill((200, 200, 200))

+    

+       

+    heroNumber = random.randint(3,17)

+    levelNum = 0

+    

+    level = generateScreen(background,levelNum)

+    background = level[0]

+    walls = level[1]

+    gaps = level[2]

+    gapNumbers = level[3]

+        

+	#Grid, for display purposes

+    grid = 0

+    if grid == 1:

+        for i in range(24):

+            pygame.draw.line(background, [0,0,0], (50*i,0),(50*i,900))

+        for i in range(18):

+            pygame.draw.line(background, [0,0,0], (0,50*i),(1200,50*i))

+    

+    

+    screen.blit(background, (0, 0))

+    pygame.display.flip()

+    

+        

+    hero = pygame.Rect(600, 700, 70, 100)   #The rectangle representing the hero

+    

+    dropRects = []

+    dropValues = []

+    dropStrings = []

+

+    updateGaps = 1  #The variable that stores if the gaps need to be updated(set to 1 whenever the heroes number changes), also need to update at start

+    updateRects = [] #The list of rectangles on the screen representing the portions of the screen that need to be updated

+    

+    #Sets the movement speeds for the character, in pixels per loop increment (game runs at 40 FPS)

+    sideSpeed = 10

+    upSpeed = 20    

+    gravity = 10

+    xchange = 0

+    ychange = gravity

+    

+    clock = pygame.time.Clock()

+    

+    shownGap1, shownGap2 = None, None   #Variables will represent gaps that will be displayed (if they get hit or stepped on)

+    fallWait, topHoleWait = 0, 0    #Variables representing timers for if the hero is falling or a gap is being displayed because it was stepped on

+    

+    run = 1 #Variable representing if the game is running

+    runCounter = 0 #The number of run loops the game has gone through

+    

+    #The main game loop of the program

+    while run:

+        runCounter = runCounter+1

+        events = pygame.event.get()

+        for event in events: 

+            #User decides to exit program

+            if event.type == QUIT:              

+                run = 0 #stop running

+                

+            #Triggers when a key is first pressed down    

+            elif event.type == pygame.KEYDOWN:  

+                if event.key == 273:   #up

+                    ychange += -upSpeed

+                elif event.key == 274: #down

+                    ychange += 0

+                elif event.key == 275: #right

+                    xchange += sideSpeed

+                elif event.key == 276: #left

+                    xchange += -sideSpeed

+                elif event.unicode == "+":

+                    heroNumber = heroNumber+1

+                    updateGaps = 1

+                elif event.unicode == "-":

+                    heroNumber = heroNumber-1

+                    updateGaps = 1

+            

+            #Triggers when a pressed down key is no longer being pressed

+            elif event.type == pygame.KEYUP:

+                if event.key == 273:

+                    ychange += +upSpeed

+                elif event.key == 274:

+                    ychange += 0

+                elif event.key == 275:

+                    xchange += -sideSpeed

+                elif event.key == 276:

+                    xchange += +sideSpeed

+        

+        #Sees if the lists storing the gaps which are impassable need to be updated

+        if updateGaps != 0:

+            updateGaps = 0

+            

+            impassableGaps = []     #The list that will store all the gaps that are not currently passable because of the heroes current number

+            impassableWalls = util.merge([],walls) #Combined list representing impassable gaps and all walls

+            

+            #Goes through every gap on the screen and checks if it is impassable or not, if so adds to appropriate lists

+            for i in range(len(gaps)):

+                if not(gapNumbers[i][0]<=heroNumber<=gapNumbers[i][1] or gapNumbers[i][0]>=heroNumber>=gapNumbers[i][1]):

+                    if hero.collidelist([gaps[i]]) == -1:   #makes sure the hero isn't in the gap currently (prevents it from getting stuck)

+                        impassableGaps.append(gaps[i])

+                        impassableWalls.append(pygame.Rect(gaps[i][0],gaps[i][1],gaps[i][2],1))

+        

+        #Start of hero movement/collision detection block

+        if fallWait != 0:   #The hero is falling, so movement is not based on arrow keys pressed

+            fallWait = fallWait - 1

+            tempXChange = 0     #hero does not move left or right, just falls based o gravity

+            tempYChange = gravity

+            if fallWait <= 20:  #After done falling for a while stops showing the gap which was hit

+                shownGap1 = None

+        else:       #hero is not falling, movement based on the modifiers from the arrow keys.

+            shownGap1 = None

+            tempXChange = xchange

+            tempYChange = ychange

+        

+        tempHero = hero.move(tempXChange,tempYChange) 

+            

+        if tempHero.collidelist(impassableWalls) == -1:   #no collision problems, hero moves normally

+            hero = tempHero

+        else:

+            tempHero = hero.move(tempXChange,0)        # first checks if collision is from vertical movement,

+            if tempHero.collidelist(impassableWalls) == -1:  # if it is, move hero horizontally only

+                hero = tempHero

+            else:

+                tempHero = hero.move(0,tempYChange)    # otherwise, checks if collision is from horizontal movement

+                if tempHero.collidelist(impassableWalls) == -1:

+                    hero = tempHero

+                    

+                    

+        #If collison comes from both horizontal and verical movements, the hero does not get moved

+        

+        #checks if the hero hits a gap they cannot pass through from the bottom

+        if hero.collidelist(impassableGaps) != -1:

+            fallWait = 60   #Sets the variable representing the fact that the hero is falling, because they went the wrong way

+            shownGap1 = impassableGaps[hero.collidelist(impassableGaps)]

+            

+        #checks if the hero is standing on top of a gap they cannot pass through    

+        tempHero = hero.inflate(-70,0)

+        tempHero = tempHero.move(0,1)

+        if tempHero.collidelist(impassableGaps) != -1:

+            topHoleWait = 5     #gap hero is standing on stays for 5 increments after it's off

+            gap = impassableGaps[tempHero.collidelist(impassableGaps)]

+            shownGap2 = pygame.Rect(gap.topleft,(gap.width,20))

+            

+            

+            

+        #re-draws the background

+        #screen.blit(background, (0, 0))

+        for rect in updateRects:

+            screen.blit(background,rect,rect)

+            

+        prevUpdateRects = updateRects

+        updateRects = []

+        

+        pygame.draw.rect(screen, [255,50,50], hero) #draws the hero

+        updateRects.append(hero)

+        

+        #Checks if any impassable gaps have been hit or stepped on and thus need to be displayed

+        if shownGap1 != None:

+            pygame.draw.rect(screen, [250,100,100,50], shownGap1)

+            updateRects.append(shownGap1)

+        if topHoleWait != 0:

+            topHoleWait = topHoleWait - 1

+            pygame.draw.rect(screen, [250,100,100,50], shownGap2)

+            updateRects.append(shownGap2)

+        

+        #Code which spawns a drop which contains a number, only called every 100 loops

+        if runCounter%75 == 0:

+            newDrop = generateDropNumber(heroNumber,levelNum)

+            dropRects.append(pygame.Rect(random.randint(150,850),0,50,50))

+            dropValues.append(newDrop[0:2])

+            dropStrings.append(newDrop[2])

+               

+        #Checks if hero has hit any drops

+        if hero.collidelist(dropRects) != -1:

+            i = hero.collidelist(dropRects)

+            if dropValues[i][0] == 0:       #hit an addition drop

+                if heroNumber + dropValues[i][1] < 1000:

+                    heroNumber = heroNumber + dropValues[i][1]

+                    dropRects.pop(i)

+                    dropValues.pop(i)

+                    dropStrings.pop(i)

+                    updateGaps = 1

+                    

+            elif dropValues[i][0] == 1:     #hit a subtraction drop

+                if -1000 < heroNumber - dropValues[i][1]:

+                    heroNumber = heroNumber - dropValues[i][1]

+                    dropRects.pop(i)

+                    dropValues.pop(i)

+                    dropStrings.pop(i)

+                    updateGaps = 1

+                    

+            elif dropValues[i][0] == 2:     #Multiplication drop

+                if -1000 < heroNumber*dropValues[i][1] < 1000:

+                    heroNumber = heroNumber * dropValues[i][1]

+                    dropRects.pop(i)

+                    dropValues.pop(i)

+                    dropStrings.pop(i)

+                    updateGaps = 1

+                        

+            elif dropValues[i][0] == 3:     #Division drop

+                if heroNumber%dropValues[i][1] == 0:

+                    heroNumber = heroNumber / dropValues[i][1]

+                    dropRects.pop(i)

+                    dropValues.pop(i)

+                    dropStrings.pop(i)

+                    updateGaps = 1

+            

+        #Goes through every drop currently on screen (starting with most recently spawned), draws it to the screen with the appropriate number, and moves it down

+        dropIndexs = range(len(dropRects))

+        dropIndexs.reverse()        

+        

+        font = pygame.font.Font(None,42)    #The font 

+        for i in dropIndexs:

+            dropBox = font.render(dropStrings[i], 1, (50,50,230))

+            textSize = font.size(dropStrings[i])

+            dropRect = pygame.Rect(dropRects[i].topleft[0]+(50-textSize[0])/2,dropRects[i].topleft[1]+(50-textSize[1])/2,textSize[0],textSize[1])

+            #screen.blit(dropBox, (dropRects[i].topleft[0]+(50-textSize[0])/2,dropRects[i].topleft[1]+(50-textSize[1])/2))

+            screen.blit(dropBox, dropRect)

+            updateRects.append(dropRect)

+            dropRects[i] = dropRects[i].move(0,2)

+            if dropRects[i].topleft[1]>=900:    #Removes from all applicable lists if no longer on screen

+                dropRects.pop(i)

+                dropValues.pop(i)

+                dropStrings.pop(i)

+        

+        #Sets up and displays the box which contains the number the hero currently has

+        numBox = pygame.Rect(0,0,60,30)

+        hero_number_box = util.render_textrect(str(heroNumber),pygame.font.Font(None, 40),numBox,(50,50,50),[250,250,250],0,1)

+        screen.blit(hero_number_box, (hero.topleft[0]+5,hero.topleft[1]+35))

+        #pygame.display.flip()   #updates screen

+        pygame.display.update(prevUpdateRects)

+        pygame.display.update(updateRects)

+        

+        #Made it off the top of the screen, must advance to next level

+        if hero.topleft[1] <= -80:

+                levelNum = levelNum+1

+                if levelNum == 8:   #Made it to the top of the tower!

+                    victoryCinematic(screen)

+                    break

+                    

+                #Copy copies the second floor displayed on the screen so it can be shown as the very bottom on the next level 

+                for gap in gaps:

+                    pygame.draw.rect(background,[250,100,100,50], gap)

+                    

+                copy = background.subsurface(pygame.Rect(100,150,1000,50)).copy()

+                

+                #Clears background, generate new level/get it saved into variables

+                background.fill((200, 200, 200))

+                level = generateScreen(background,levelNum)

+                background = level[0]

+                walls = level[1]

+                gaps = level[2]

+                gapNumbers = level[3]

+                

+                #Clear the falling numbers from the screen

+                dropRects, dropValues, dropStrings = [], [], []

+                

+                #Reset heros vertical location

+                hero = pygame.Rect(hero.topleft[0],700,70,100)

+                

+                #As the level has changed, gaps need to be updated again

+                updateGaps = 1

+                

+                #As there is a new background, need to set to update the whole screen

+                updateRects = [pygame.Rect(0,0,1200,900)]

+                prevUpdateRects = []

+        

+                #makes the botton floor of the new screen the same as the top floor of the old one

+                background.blit(copy, (100,850))

+                print "Now on level %d."%(levelNum)

+                

+        print clock

+        clock.tick(40) #limits to 40 FPS

+	

+    

+def main():

+    print "Running Tower"

+    run()

+    

+

+#Given a number, returns a string representing the number, randomly formated into a short math equasion    

+def stringFactor(number):

+    #The list which represents the string posibilities which will be chosen from later

+    choices = []

+    

+    if number == 0:  #special case if the number is 0, string possibilites are 0 times a number from 2~12

+        for i in range(13)[1:]:

+            choices.append("%dx%d"%(0,i))

+            choices.append("%dx%d"%(i,0))

+    else:           # Number is non-zero

+        #Checks if the number is a multiple of 2~12x2~12, adds all possibilities to list

+        for i in range(13)[2:]:

+            if number%i == 0:

+                if 1 < number/i <= 12:

+                    choices.append("%dx%d"%(i,number/i))

+                   

+    

+    #Sees if no possibilities found yet:

+    if len(choices) == 0:

+        #Adds the number itself to choices multiple times to make that choice more likely

+        for i in range(6):

+            choices.append("%d"%(number))

+        #choices.append(u"%d\u00F75"%(number*5)) #Five times the number divided by 5

+        choices.append(u"%d\u00F72"%(number*2)) # Double the number divided by 2

+        if number<100:

+            choices.append("%dx10+%d"%(number/10,number%10))#expanded notation

+     

+    #selects a single entry at random from the possible choices, and returns the string

+    return random.sample(choices,1)[0]    

+    

+

+# Executed once the player reaches the top of the tower    

+def victoryCinematic(screen):

+    

+    util.ok_box("You have reached the top of the tower!", (450,400), 300, 50, screen)

+    

+def generateDropNumber(heroNumber,level):

+    #Randomly selects if the drop will have addition, subtraction, multiplication, or division, addition and subtraction being more likely

+    type = random.sample([0,0,0,0,0,0,1,1,1,1,1,1],1)[0]

+    levelAverage = (levelRanges[level][0]+levelRanges[level][1])/2    

+    returnString = ""

+    if type == 0: #Addition drop

+        number = random.randint(2,15)

+        if heroNumber-levelAverage < -30:

+            number = random.sample([number,-number-heroNumber+levelAverage],1)[0]

+        returnString = "+%d"%(number)

+    elif type == 1: #Subtraction drop

+        number = random.randint(2,9)

+        if heroNumber-levelAverage > 30:

+            number = random.sample([number,number+heroNumber-levelAverage],1)[0]

+        returnString = "-%d"%(number)    

+    elif type == 2: #Multiplication drop

+        number = random.randint(2,5)

+        returnString = "x%d"%(number)      

+    elif type == 3: #Division drop

+        number = random.randint(2,5)

+        returnString = u"\u00F7%d"%(number)

+        

+    return (type,number,returnString)

+    

+#runs main if called via other naming convention

+if __name__ == '__main__': main()
\ No newline at end of file
diff --git a/tower_map.bmp b/tower_map.bmp
new file mode 100644
index 0000000..16da85e
--- /dev/null
+++ b/tower_map.bmp
diff --git a/tower_outside.bmp b/tower_outside.bmp
new file mode 100644
index 0000000..2ab4b68
--- /dev/null
+++ b/tower_outside.bmp
diff --git a/tower_outside_controls.bmp b/tower_outside_controls.bmp
new file mode 100644
index 0000000..e743d14
--- /dev/null
+++ b/tower_outside_controls.bmp
diff --git a/util.py b/util.py
index 778d2e9..70c5307 100644..100755
--- a/util.py
+++ b/util.py
@@ -7,7 +7,7 @@ import string
 

 def load_image(file, trans = 0):

     "loads an image, prepares it for play"

-    file = os.path.join('data', file)

+    #file = os.path.join('data', file)

     try:

         surface = pygame.image.load(file)

         if trans == 1:        

diff --git a/util.pyc b/util.pyc
new file mode 100755
index 0000000..139cd4b
--- /dev/null
+++ b/util.pyc
diff --git a/wall.bmp b/wall.bmp
new file mode 100644
index 0000000..8c46027
--- /dev/null
+++ b/wall.bmp
diff --git a/watch3.bmp b/watch3.bmp
new file mode 100644
index 0000000..e5cff2d
--- /dev/null
+++ b/watch3.bmp
diff --git a/watch_broken2.bmp b/watch_broken2.bmp
new file mode 100644
index 0000000..a1a038c
--- /dev/null
+++ b/watch_broken2.bmp
diff --git a/watch_drop_bg.bmp b/watch_drop_bg.bmp
new file mode 100644
index 0000000..4d2e939
--- /dev/null
+++ b/watch_drop_bg.bmp
diff --git a/wave.bmp b/wave.bmp
new file mode 100644
index 0000000..08f276d
--- /dev/null
+++ b/wave.bmp
diff --git a/wave2.bmp b/wave2.bmp
new file mode 100644
index 0000000..320d67d
--- /dev/null
+++ b/wave2.bmp