120721

config.txt

-default_song = phat
-theme = red2
+default_song = snaps
+theme = default
 title = default
 bpm = 90
 volume = 10

defender_scores.sco

+name1 = zilla
+name2 = robzilla
+name3 = zilla
+score1 = 1950
+score2 = 2050
+score3 = 2050

lib/FSM.py

 
 import StatesProg
-   
+import StatesDefender   
 #====================================
 class Transition(object):
     def __init__(self, toState):
     def Execute(self):
         pass
                         
-#===================================
+#===================================-
                         
 class FSM(object):
     def __init__ (self, character, owner):
         self.owner = owner
         self.name = None
         self.last_state_notes = None
+        self.queued_state = None
         
     def AddTransition(self, transName, transition):
         self.transitions[transName] = transition
         'Ping', 
         'Wifi',
         'Defender',
-        'Update'
+        'Update',
+        'Calculator'
         ]
         
         for s in state_list:
 
 #=================================== 
         
+class DefenderFSM(Char):
+    def __init__(self, owner):
+        self.FSM = FSM(self, owner)
+        self.owner = owner
+        
+        state_list = [
+        'Startup',
+        'Intro',
+        'Main',
+        'BlueFade',
+        'GreyFade',
+        'GameOver',
+        'HighScore',
+        'NewHighScore',
+        'EnterText'
+        ]
+        
+        for s in state_list:
+            self.FSM.AddState(s, getattr(StatesDefender, s)(self.FSM))
+            t = 'to' + s
+            self.FSM.AddTransition(t, Transition(s))
+        
+        if self.FSM.curState == None:
+            self.FSM.SetState('Startup')
+    
+    def Execute(self):
+        self.FSM.Execute(self.owner)    
+
+#=================================== 
+        

lib/StatesDefender.py

+import random
+import time
+import pygame
+import sys
+import pyaudio
+import wave
+import glob
+import os
+import ast 
+from configobj import ConfigObj
+from itertools import cycle
+
+class Game:
+	def __init__(self, o):
+		self.o = o
+		
+		self.last_frame_time = time.perf_counter()	
+		self.bullets = []
+		self.bullet_speed = 80
+		self.delta = 0.00001
+		self.sidebar_width = 80
+		self.gw = o.width - self.sidebar_width
+		self.score = 0
+		self.time = 0
+		self.player = Player(o, self)
+		self.enemies = []
+		self.birth = pygame.time.get_ticks()
+		self.last_enemy_spawn = pygame.time.get_ticks()
+		self.enemy_spawn_delay = 2000
+		self.explodes = []
+		self.explode_speed = 80
+		self.hs_name = ""
+		self.speed_mult = 1.0
+		self.speed_mult_inc = .1
+		self.mult_state = 3
+		# self.hs_n1 = "billy"
+		# self.hs_n2 = "joe"
+		# self.hs_n3 = "robzilla"
+		# self.hs_s1 = 10
+		# self.hs_s2 = 40
+		# self.hs_s3 = 100
+		self.load_highscore()
+		#self.save_highscore()
+		self.game_over = False
+		
+		print('aaay making a game')
+
+	def update(self):
+		self.delta = time.perf_counter() - self.last_frame_time
+		self.last_frame_time = time.perf_counter()
+		#print(self.delta)
+		self.o.draw.rectangle((0, 0, self.o.width, self.o.height), outline=0, fill=self.o.blue)
+		#print('playing game ', self.player.posy)
+		self.mstime = (pygame.time.get_ticks() - self.birth)
+		self.time = int(self.mstime * .001)
+		if self.time > self.mult_state:
+			self.mult_state += 3
+			if self.speed_mult < 2.5:
+				self.speed_mult += self.speed_mult_inc
+			if self.enemy_spawn_delay > 1000:
+				self.enemy_spawn_delay -= 50
+			print('....level up ', self.speed_mult)
+		#print(self.mstime % 100.0)
+		#if self.mstime % 100.0 == 0:
+			#print('up level')
+			#self.speed_mult += self.speed_mult_inc
+		self.enemy_spawner()
+		self.draw_bullets()
+		self.draw_enemies()
+		self.draw_explodes()
+		self.player.update(self.delta)
+		self.draw_sidebar()
+		self.o.update_display(self.o)
+
+	def draw_bullets(self):
+		for x in self.bullets:
+			x.check_collision()
+			x.update()
+			x.draw()
+
+	def draw_enemies(self):
+		for x in self.enemies:
+			x.check_collision()
+			x.update()
+			x.draw()
+
+	def draw_explodes(self):
+		for x in self.explodes:
+			#x.check_collision()
+			x.update()
+			x.draw()
+
+	def draw_sidebar(self):
+		w = self.o.width - self.sidebar_width
+		self.o.draw.rectangle((w, 0, self.o.width, self.o.height), outline=0, fill=self.o.light_grey)
+		inc = 40
+		h = 10
+		self.o.center_block("Score", self.o.h2, [w, h, self.o.width, h + 10], self.o.blue)
+		h += inc
+		self.o.center_block(str(self.score), self.o.h2, [w, 15, self.o.width, h + 10], self.o.blue)
+		h += (inc * 2)
+		self.o.center_block("Time", self.o.h2, [w, 30, self.o.width, h + 10], self.o.blue)
+		h += inc
+		self.o.center_block(str(self.time), self.o.h2, [w, 40, self.o.width, h + 10], self.o.blue)
+
+	def enemy_spawner(self):
+		sl = pygame.time.get_ticks() - self.last_enemy_spawn
+		if len(self.enemies) < 1 or sl > self.enemy_spawn_delay:
+			new_e = Enemy(self.o, self)
+			self.enemies.append(new_e)
+			self.last_enemy_spawn = pygame.time.get_ticks()
+
+
+	def save_highscore(self):
+		base_dir = "/home/pi/zpc_ct/"
+		title = "defender_scores"
+		fname = base_dir + title + '.sco'
+		if os.path.exists(fname):
+			os.utime(fname, None)
+			print(fname, ' exists')
+		else:
+			print('make a damn file ', fname)
+			open(fname, 'a').close()			
+
+		self.sconf = ConfigObj(fname)
+		self.sconf['name1'] = self.hs_n1
+		self.sconf['name2'] = self.hs_n2
+		self.sconf['name3'] = self.hs_n3
+		self.sconf['score1'] = self.hs_s1
+		self.sconf['score2'] = self.hs_s2
+		self.sconf['score3'] = self.hs_s3
+		
+		self.sconf.write()
+
+	def load_highscore(self):
+		base_dir = "/home/pi/zpc_ct/"
+		self.sconf = ConfigObj(base_dir + 'defender_scores.sco')
+		self.hs_n1 = self.sconf['name1']
+		self.hs_n2 = self.sconf['name2']
+		self.hs_n3 = self.sconf['name3']
+		self.hs_s1 = self.sconf.as_int('score1')
+		self.hs_s2 = self.sconf.as_int('score2')
+		self.hs_s3 = self.sconf.as_int('score3')
+		
+
+class Player:
+	def __init__(self, o, game):
+		self.o = o
+		self.game = game
+		self.width = 28
+		self.height = 12
+		self.speed = 80
+		self.posx = game.gw / 2
+		self.posy = o.height - self.height
+		
+
+	def update(self, delta):
+		self.check_keys(delta)
+		self.draw_player()
+		#check position
+		#pass
+	def draw_player(self):
+		hw = self.width / 2
+		hh = self.height / 2
+		self.o.draw.rectangle(((self.posx - hw), (self.posy - hh), (self.posx + hw), (self.posy + hh)), outline=self.o.light_grey, fill=self.o.light_grey)
+		self.o.draw.rectangle(((self.posx - (hw/4)), (self.posy - self.height), (self.posx + (hw/4)), (self.posy + hh)), outline=self.o.light_grey, fill=self.o.light_grey)
+
+
+	def check_keys(self, delta):
+		if self.o.keyState[0] == 2:
+			if self.posx > 0:
+				self.posx -= self.speed * delta
+		elif self.o.keyState[3] == 2:
+			if self.posx < self.o.width:
+				self.posx += self.speed * delta
+
+		elif self.o.keyState[1] == 1 or self.o.keyState[2] == 1:
+			self.game.bullets.append(Bullet(self.o, self.game, self.posx))
+
+class Bullet:
+	def __init__(self, o, game, x):
+		self.o = o
+		self.game = game
+		self.posx = x
+		self.posy = 110
+		self.width = 3
+		self.height = 10
+
+	def draw(self):
+		hw = self.width / 2
+		hh = self.height / 2
+		self.o.draw.rectangle(((self.posx - hw), (self.posy - hh), (self.posx + hw), (self.posy + hh)), outline=0, fill=self.o.light_grey)		
+
+	def update(self):
+		self.posy -= self.game.bullet_speed * self.game.delta
+		if self.posy < 0:
+			self.game.bullets.remove(self)
+			#print('killing bullet ', len(self.game.bullets))
+		self.draw()
+
+	def check_collision(self):
+		pass
+
+class Enemy:
+	def __init__(self, o, game):
+		self.o = o
+		self.game = game
+		self.posx = game.gw / 2
+		self.posy = -20
+		self.width = 20
+		self.height = 15
+		self.speed = random.randrange(15, 30) * game.speed_mult
+		self.xspeed = random.randrange(0, 30) * game.speed_mult
+		self.point_value = 50
+
+		self.ydir = random.choice([-1, 1])
+
+	def draw(self):
+			hw = self.width / 2
+			hh = self.height / 2
+			self.o.draw.rectangle(((self.posx - hw), (self.posy - hh), (self.posx + hw), (self.posy + hh)), outline=self.o.light_grey, fill=self.o.light_grey)		
+			self.o.draw.rectangle(((self.posx - hw + 5), (self.posy - hh + 10), (self.posx + hw - 5), (self.posy + hh)), outline=self.o.blue, fill=self.o.blue)		
+			#eyes
+			# self.o.draw.rectangle(((self.posx - 8), (self.posy - 5), (self.posx - 5), (self.posy - 3)), outline=self.o.blue, fill=self.o.blue)		
+			# self.o.draw.rectangle(((self.posx + 8), (self.posy - 5), (self.posx + 5), (self.posy - 3)), outline=self.o.blue, fill=self.o.blue)		
+
+			self.o.draw.rectangle(((self.posx - 8), (self.posy - 4), (self.posx - 2), (self.posy - 3)), outline=self.o.blue, fill=self.o.blue)		
+			self.o.draw.rectangle(((self.posx + 8), (self.posy - 4), (self.posx + 2), (self.posy - 3)), outline=self.o.blue, fill=self.o.blue)		
+
+	def update(self):
+		self.posy += self.speed * self.game.delta
+		self.posx += (self.xspeed * self.ydir * self.game.delta)
+		self.check_collision()
+
+		if self.posy > self.o.height:
+			self.game.enemies.remove(self)
+			#print('killing enemy ', len(self.game.enemies))
+			self.game.game_over = True
+
+		if self.posx > (self.game.gw - (self.width / 2)):
+			self.ydir = -1
+		elif self.posx < (0 + (self.width / 2)):
+			self.ydir = 1
+
+		self.draw()
+
+	def check_collision(self):
+
+		for b in self.game.bullets:
+			xdist = abs(b.posx - self.posx)
+
+			if xdist < self.width / 2:
+				ydist = abs(b.posy - self.posy)
+				if ydist < self.height / 2:
+					#print('hit ', xdist)
+					self.game.score += self.point_value
+					if b in self.game.bullets:
+						self.game.bullets.remove(b)
+					self.die()
+				#else:
+					#print('no y hit ', ydist)
+			#else:
+				#print('no x hit ', xdist)
+
+	def die(self):
+		if self in self.game.enemies:
+			self.game.enemies.remove(self)
+			#print('enemy shot ', len(self.game.enemies))
+			self.game.explodes.append(Explode(self.o, self.game, self.posx, self.posy))
+
+class Explode:
+	def __init__(self, o, game, x, y):
+		self.o = o
+		self.game = game
+		self.posx = x
+		self.posy = y
+		self.width = 16
+		self.height = 14
+		self.gap = 5
+		self.scale_speed = 80
+
+	def draw(self):
+		hw = self.width / 2
+		hh = self.height / 2
+		c1 = [self.posx + self.gap, self.posy - self.gap]
+		c2 = [self.posx - self.gap, self.posy - self.gap]
+		c3 = [self.posx + self.gap, self.posy + self.gap]
+		c4 = [self.posx - self.gap, self.posy + self.gap]
+		
+		self.o.draw.rectangle(((c1[0] - hw), (c1[1] - hh), (c1[0] + hw), (c1[1] + hh)), outline=0, fill=self.o.light_grey)		
+		self.o.draw.rectangle(((c2[0] - hw), (c2[1] - hh), (c2[0] + hw), (c2[1] + hh)), outline=0, fill=self.o.light_grey)		
+		self.o.draw.rectangle(((c3[0] - hw), (c3[1] - hh), (c3[0] + hw), (c3[1] + hh)), outline=0, fill=self.o.light_grey)		
+		self.o.draw.rectangle(((c4[0] - hw), (c4[1] - hh), (c4[0] + hw), (c4[1] + hh)), outline=0, fill=self.o.light_grey)		
+
+	def update(self):
+		#self.posy -= self.game.bullet_speed * self.game.delta
+		self.gap += self.game.explode_speed * self.game.delta
+		self.width -= self.scale_speed * self.game.delta
+		self.height -= self.scale_speed * self.game.delta
+		if self.gap > 20:
+			self.game.explodes.remove(self)
+			print('killing explosion ', len(self.game.explodes))
+		self.draw()
+
+	def check_collision(self):
+		pass
+
+#====================================     
+
+State = type("State", (object,), {})
+#====================================     
+class State(object):
+	def __init__(self, FSM):
+		self.FSM = FSM
+		self.timer = 0
+		self.startTime = 0
+	def Enter(self):
+		self.timer = 0
+		self.startTime = 0
+	def Execute(self):
+		print('Executing')
+	def Exit(self):
+		print('Exiting')
+
+#==================================== 
+
+class Example(State):
+	def __init__(self,FSM):
+		super(Example, self).__init__(FSM)    
+		
+	def Enter(self):
+		self.FSM.stateLife = 1
+		super(Example, self).Enter()        
+		
+	def Execute(self):
+		self.FSM.stateLife += 1
+		
+	def Exit(self):
+		pass
+
+#==================================== 
+
+class Startup(State):
+	def __init__(self,FSM):
+		super(Startup, self).__init__(FSM)    
+		
+	def Enter(self):
+		self.FSM.stateLife = 1
+		self.birth = time.perf_counter()
+		super(Startup, self).Enter()        
+		
+	def Execute(self):
+		print('defender startup state')
+		self.FSM.ToTransition('toIntro')
+		
+	def Exit(self):
+		pass
+
+#==================================== 
+			
+class Intro(State):
+	def __init__(self,FSM):
+		super(Intro, self).__init__(FSM)    
+		
+	def Enter(self):
+		self.birth = time.perf_counter()
+		o = self.FSM.owner 
+		o.draw.rectangle((0, 0, o.width, o.height), outline=0, fill=o.blue)
+		o.center_block("Welcome To Defender", o.h2, [0, 0, o.width, o.height], o.light_grey)
+		o.update_display(0)
+		super(Intro, self).Enter()        
+		
+	def Execute(self):
+		#print('doing defender intro ', (time.perf_counter() - self.birth))
+		if (time.perf_counter() - self.birth) > 2:
+			print('time is up')
+			self.FSM.queued_state = "toMain"
+			self.FSM.ToTransition('toBlueFade')
+			#self.FSM.ToTransition('toMain')
+
+	def Exit(self):
+		pass
+
+#==================================== 
+
+#==================================== 
+			
+class Main(State):
+	def __init__(self,FSM):
+		super(Main, self).__init__(FSM)    
+		
+	def Enter(self):
+		print('hello defender main')
+		o = self.FSM.owner 
+		o.draw.rectangle((0, 0, o.width, o.height), outline=0, fill=o.blue)
+		o.update_display(0)
+		self.game = Game(o)
+		o.game = self.game
+
+		super(Main, self).Enter()        
+		
+	def Execute(self):
+		self.game.update()
+		if self.game.game_over:
+			
+			self.FSM.queued_state = "toGameOver"
+			self.FSM.ToTransition('toBlueFade')
+
+	def Exit(self):
+		pass
+
+#==================================== 
+
+class BlueFade(State):
+	def __init__(self,FSM):
+		super(BlueFade, self).__init__(FSM)    
+		
+	def Enter(self):
+		self.FSM.stateLife = 1
+		self.birth = pygame.time.get_ticks()
+		self.last_frame_time = time.perf_counter()	
+		self.o = self.FSM.owner 
+		self.x = self.o.width / 2
+		self.y = self.o.height / 2
+		self.xsize = 0.0
+		self.ysize = 0.0
+
+		super(BlueFade, self).Enter()        
+		
+	def Execute(self):
+		self.FSM.stateLife += 1
+		self.delta = time.perf_counter() - self.last_frame_time
+		self.last_frame_time = time.perf_counter()
+
+
+		self.o.draw.rectangle((self.x - self.xsize, self.y - self.ysize, self.x + self.xsize, self.y + self.ysize), outline=self.o.blue, fill=self.o.blue)
+		self.o.update_display(self.o)
+		self.xsize += self.delta * 150
+		self.ysize += self.delta * 125
+		if (pygame.time.get_ticks() - self.birth > 1000):
+
+			print('get outta fade')
+			if self.FSM.queued_state != None:
+				ns = self.FSM.queued_state 
+				self.FSM.queued_state = None
+				self.FSM.ToTransition(ns)	
+	def Exit(self):
+		pass
+
+#==================================== 
+
+
+class GreyFade(State):
+	def __init__(self,FSM):
+		super(GreyFade, self).__init__(FSM)    
+		
+	def Enter(self):
+		self.FSM.stateLife = 1
+		self.birth = pygame.time.get_ticks()
+		self.last_frame_time = time.perf_counter()	
+		self.o = self.FSM.owner 
+		self.x = self.o.width / 2
+		self.y = self.o.height / 2
+		self.xsize = 0.0
+		self.ysize = 0.0
+
+		super(GreyFade, self).Enter()        
+		
+	def Execute(self):
+		self.FSM.stateLife += 1
+		self.delta = time.perf_counter() - self.last_frame_time
+		self.last_frame_time = time.perf_counter()
+
+
+		self.o.draw.rectangle((self.x - self.xsize, self.y - self.ysize, self.x + self.xsize, self.y + self.ysize), outline=self.o.light_grey, fill=self.o.light_grey)
+		self.o.update_display(self.o)
+		self.xsize += self.delta * 150
+		self.ysize += self.delta * 125
+		if (pygame.time.get_ticks() - self.birth > 1000):
+
+			print('get outta fade')
+			if self.FSM.queued_state != None:
+				ns = self.FSM.queued_state 
+				self.FSM.queued_state = "toMain"
+				self.FSM.ToTransition(ns)
+		
+	def Exit(self):
+		pass
+
+#==================================== 
+
+class GameOver(State):
+	def __init__(self,FSM):
+		super(GameOver, self).__init__(FSM)    
+		
+	def Enter(self):
+		self.FSM.stateLife = 1
+		self.o = self.FSM.owner 
+		self.birth = pygame.time.get_ticks()
+
+		self.o.draw.rectangle((0, 0, self.o.width, self.o.height), outline=0, fill=self.o.blue)
+		self.o.center_block("Game Over", self.o.h2, [0, 0, self.o.width, self.o.height], self.o.light_grey)
+		self.o.center_block("Score: " + str(self.o.game.score), self.o.h2, [0, 20, self.o.width, self.o.height + 20], self.o.light_grey)
+		self.o.update_display(0)
+
+		super(GameOver, self).Enter()        
+		
+	def Execute(self):
+		#self.FSM.stateLife += 1
+		if self.o.keyState[0] == 1:
+			#self.FSM.ToTransition("toMain")
+			self.FSM.queued_state = "toMain"
+			self.FSM.ToTransition('toBlueFade')
+
+		if (pygame.time.get_ticks() - self.birth) > 3000:
+			if self.o.game.score > self.o.game.hs_s1:
+				print('this is a new high score')
+				self.FSM.queued_state = "toNewHighScore"
+			else:
+				print('not a new high score')				
+			
+				self.FSM.queued_state = "toHighScore"
+			self.FSM.ToTransition('toBlueFade')
+
+
+	def Exit(self):
+		pass
+
+#==================================== 
+
+
+class HighScore(State):
+	def __init__(self,FSM):
+		super(HighScore, self).__init__(FSM)    
+		
+	def Enter(self):
+		#self.FSM.stateLife = 1
+		self.o = self.FSM.owner 
+
+
+		self.o.draw.rectangle((0, 0, self.o.width, self.o.height), outline=0, fill=self.o.blue)
+		self.o.center_text("HIGH SCORES", self.o.h1, self.o.width, 25, self.o.light_grey)
+		self.o.center_text("----------------------", self.o.h2, self.o.width, 55, self.o.light_grey)
+
+
+		#self.o.draw.rectangle((0, 0, self.o.width, self.o.height), outline=0, fill=self.o.blue)
+		self.o.center_block(self.o.game.hs_n3 + ': ' + str(self.o.game.hs_s3), self.o.h2, [0, -20, self.o.width, self.o.height-20], self.o.light_grey)
+		self.o.center_block(self.o.game.hs_n2 + ': ' + str(self.o.game.hs_s2), self.o.h2, [0, 0, self.o.width, self.o.height], self.o.light_grey)
+		self.o.center_block(self.o.game.hs_n1 + ': ' + str(self.o.game.hs_s1), self.o.h2, [0, 20, self.o.width, self.o.height+20], self.o.light_grey)
+		self.o.center_block("restart", self.o.h2, [0, 50, self.o.width, self.o.height + 50], self.o.light_grey)
+		self.o.update_display(0)
+
+
+		super(HighScore, self).Enter()        
+		
+	def Execute(self):
+		#self.FSM.stateLife += 1
+		if self.o.keyState[0] == 1:
+			#self.FSM.ToTransition("toMain")
+			self.FSM.queued_state = "toMain"
+			self.FSM.ToTransition('toBlueFade')
+
+		
+	def Exit(self):
+		pass
+
+#==================================== 
+
+#==================================== 
+			
+class NewHighScore(State):
+	def __init__(self,FSM):
+		super(NewHighScore, self).__init__(FSM)    
+		
+	def Enter(self):
+		self.birth = time.perf_counter()
+		o = self.FSM.owner 
+		o.draw.rectangle((0, 0, o.width, o.height), outline=0, fill=o.blue)
+		o.center_block("NEW HIGH SCORE!", o.h2, [0, 0, o.width, o.height], o.light_grey)
+		o.update_display(0)
+		super(NewHighScore, self).Enter()        
+		
+	def Execute(self):
+		#print('doing defender intro ', (time.perf_counter() - self.birth))
+		if (time.perf_counter() - self.birth) > 2:
+			print('time is up')
+			self.FSM.queued_state = "toEnterText"
+			self.FSM.ToTransition('toBlueFade')
+			#self.FSM.ToTransition('toMain')
+
+	def Exit(self):
+		pass
+
+#==================================== 
+class EnterText(State):
+	def __init__(self,FSM):
+		super(EnterText, self).__init__(FSM)    
+		
+	def Enter(self):
+		o = self.FSM.owner 
+	
+		self.input_string = ""
+		
+		self.last_action = pygame.time.get_ticks()
+		self.caps = False
+		self.cur_but = 18
+		self.cur_letter = ""
+
+		self.skips = [7, 3, 11, 12, 13, 14, 15]
+		
+		self.lc_labels = [["p", "q", "r", "s"], ["t", "u", "v"], ["w", "x", "y", "z"], ["C", "A", "P", "S"], 
+				["g", "h", "i"], ["j", "k", "l"], ["m", "n", "o"], ["D", "E", "L"],
+				["_", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "-"], ["a", "b", "c"], ["d", "e", "f"], ["O", "K"],
+				[], [], [], []]
+
+		self.uc_labels = [["P", "Q", "R", "S"], ["T", "U", "V"], ["W", "X", "Y", "Z"], ["C", "A", "P", "S"], 
+				["G", "H", "I"], ["J", "K", "L"], ["M", "N", "O"], ["D", "E", "L"],
+				["_", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "-"], ["A", "B", "C"], ["D", "E", "F"], ["O", "K"],
+				[], [], [], []]
+
+		self.labels = self.lc_labels
+
+		#self.songCycle = cycle(self.song)
+		#self.curPattern = next(self.songCycle)
+
+		self.cycles = []
+		for l in self.labels:
+			self.cycles.append(cycle(l))
+
+
+
+		self.draw(o)
+		o.update_display(0)
+		super(EnterText, self).Enter()        
+		
+	def Execute(self):
+		o = self.FSM.owner 
+		y_size = o.height / 4
+		if o.keyState[11] == 1:
+			if self.input_string != 'blank':
+				o.game.hs_name = self.input_string
+				#o.bpm = o.sconf['bpm']
+				#o.sconf['title'] = self.input_string
+				
+
+				if o.game.score > o.game.hs_s3:
+					print('new first')
+					o.game.hs_s1 = o.game.hs_s2
+					o.game.hs_n1 = o.game.hs_n2
+					o.game.hs_s2 = o.game.hs_s3
+					o.game.hs_n2 = o.game.hs_n3
+					o.game.hs_s3 = o.game.score
+					o.game.hs_n3 = o.game.hs_name
+
+				elif o.game.score > o.game.hs_s2:
+					print('new second')
+					o.game.hs_s1 = o.game.hs_s2
+					o.game.hs_n1 = o.game.hs_n2
+					o.game.hs_s2 = o.game.score
+					o.game.hs_n2 = o.game.hs_name
+				else:
+					print('new third')
+					o.game.hs_s1 = o.game.score
+					o.game.hs_n1 = o.game.hs_name
+
+				print('new high score saving')
+				#o.save_song()
+				self.FSM.queued_state = 'toHighScore'		
+				self.FSM.ToTransition('toBlueFade')		
+				o.game.save_highscore()
+
+
+
+		if o.keyState[16] > 0 and o.keyState[17] > 0:
+			pass
+		else:
+			_iter = 0
+			for k in o.keyState:
+				if k == 1:
+					cur_time = pygame.time.get_ticks()
+					print(cur_time - self.last_action)
+					
+					#print('cur letter ', next(self.cycles[_iter]))
+					if _iter not in self.skips:
+						self.last_action = cur_time
+						self.cur_letter = next(self.cycles[_iter])
+						self.cur_but = _iter
+						self.draw(o)
+						o.center_block(self.input_string + self.cur_letter, o.h2, [0, 0, o.width, y_size], o.light_grey)
+
+					if _iter == 7:
+						
+						self.input_string = self.input_string[:-1]
+						#self.input_string = self.input_string.rstrip(self.input_string[-1])
+						print('deleting')
+						self.last_action = 100000000
+						self.draw(o)
+						o.center_block(self.input_string, o.h2, [0, 0, o.width, y_size], o.light_grey)
+
+					elif _iter == 3:
+						print('caps')
+						if self.caps:
+							self.caps = False
+							self.labels = self.lc_labels
+
+						else:
+							self.caps = True
+							self.labels = self.uc_labels
+						self.draw(o)
+						o.center_block(self.input_string, o.h2, [0, 0, o.width, y_size], o.light_grey)
+						self.cycles = []
+						for l in self.labels:
+							self.cycles.append(cycle(l))
+
+					o.update_display(0)
+				_iter += 1
+
+		cur_time = pygame.time.get_ticks()
+		delay = cur_time - self.last_action
+		if delay > 1000 and delay < 100000:
+			self.input_string += self.cur_letter
+			self.last_action = 100000000
+			self.reset_cycles()
+			self.draw(o)
+
+			o.center_block(self.input_string, o.h2, [0, 0, o.width, y_size], o.light_grey)
+			o.update_display(0)
+
+	def draw(self, o):
+		x_size = o.width / 4
+		y_size = o.height / 4
+		og_x = 0
+		o_x = og_x
+		o_y = o.height
+		text_padding = 6
+		
+		_id = 0
+		while _id < 16:
+			lab = ""
+			for i in self.labels[_id]:
+				lab += i
+
+			if _id == 8:
+				lab = "_12"
+
+			o.draw.rectangle((o_x, o_y, o_x + x_size, o_y - y_size), outline=0, fill=o.blue)
+			o.center_block(lab, o.h2, [o_x, o_y, o_x + x_size, o_y - y_size], o.light_grey)
+
+			o_x = o_x + x_size
+			_id += 1
+			if _id % 4 == 0:
+				o_y -= y_size
+				o_x = og_x
+		o.draw.rectangle((0, 0, o.width, y_size), outline=0, fill=o.blue)
+		
+	def reset_cycles(self):
+		self.cycles = []
+		for l in self.labels:
+			self.cycles.append(cycle(l))
+
+	def Exit(self):
+		pass
+
+#==================================== 
+
+def timer_event():
+	print('timer event level upsssssssssssssssssssssssssss')

lib/StatesProg.py

 from pathlib import Path
 import socket
 import git 
+import FSM
 
 #====================================     
 
 			o.center_block("Vol-", o.h2, [o_x, o_y, o_x + x_size, o_y - y_size], o.light_grey)
 		if _id == 9:
 			o.center_block("Vol+", o.h2, [o_x, o_y, o_x + x_size, o_y - y_size], o.light_grey)
-		if _id == 11:
-			o.center_block("", o.h2, [o_x, o_y, o_x + x_size, o_y - y_size], o.light_grey)
+		#if _id == 11:
+			#o.center_block("", o.h2, [o_x, o_y, o_x + x_size, o_y - y_size], o.light_grey)
 		if _id == 12:
 			o.center_block("Play", o.h2, [o_x, o_y, o_x + x_size, o_y - y_size], o.light_grey)
 		if _id == 13:
 			o.center_block("Stop", o.h2, [o_x, o_y, o_x + x_size, o_y - y_size], o.light_grey)
-		if _id == 14:
+		if _id == 10:
 			o.center_block("BPM-", o.h2, [o_x, o_y, o_x + x_size, o_y - y_size], o.light_grey)
-		if _id == 15:
+		if _id == 11:
 			o.center_block("BPM+", o.h2, [o_x, o_y, o_x + x_size, o_y - y_size], o.light_grey)
 			
 
 		if _id == 3:
 			o.center_block("Load", o.h2, [o_x, o_y, o_x + x_size, o_y - y_size], o.light_grey)
 
-		if _id == 4:
+		if _id == 8:
 			o.center_block("Vol-", o.h2, [o_x, o_y, o_x + x_size, o_y - y_size], o.light_grey)
-		if _id == 5:
+		if _id == 9:
 			o.center_block("Vol+", o.h2, [o_x, o_y, o_x + x_size, o_y - y_size], o.light_grey)
 		if _id == 6:
 			o.center_block("Bank-", o.h2, [o_x, o_y, o_x + x_size, o_y - y_size], o.light_grey)
 		if _id == 7:
 			o.center_block("Bank+", o.h2, [o_x, o_y, o_x + x_size, o_y - y_size], o.light_grey)
-		if _id == 8:
+		if _id == 10:
 			o.center_block("Pitch-", o.h2, [o_x, o_y, o_x + x_size, o_y - y_size], o.light_grey)
-		if _id == 9:
+		if _id == 11:
 			o.center_block("Pitch+", o.h2, [o_x, o_y, o_x + x_size, o_y - y_size], o.light_grey)
 
 
 	   
 		o.draw.rectangle((o_x, o_y, o_x + x_size, o_y - y_size), outline=0, fill=o.dark_grey)
 
-		if _id == 0:
+		if _id == 8:
 			o.center_block("Vol -", o.h2, [o_x, o_y, o_x + x_size, o_y - y_size], o.light_grey)
-		elif _id == 1:
+		elif _id == 9:
 			o.center_block("Vol +", o.h2, [o_x, o_y, o_x + x_size, o_y - y_size], o.light_grey)
 		elif _id == 12:
 			if o.patternFollow:
 
 
 def menu1_actions(self, o):
+	if o.keyState[8] == 4 or o.keyState[8] == 3:
+		print('reset repeat from menu')
+		o.button_repeater(1,[])
+
+	if o.keyState[9] == 4 or o.keyState[9] == 3:
+		print('reset repeat from menu')
+		o.button_repeater(1,[])
+
 	if o.keyState[16] == 2:
+		#print('key 8 ', o.keyState[8])
+		#o.button_repeater(0, [8,9,14,15])
+
 		if o.keyState[0] == 1:
 			self.FSM.ToTransition('toMain')
 		elif o.keyState[1] == 1:
 			play_seq(o, [o.curPattern, 0])
 		if o.keyState[13] == 1:
 			o.stop_playback()
-		# if o.keyState[6] == 1:
-		# 	if o.note_bank > 0:
-		# 		o.note_bank -= 1
-		# if o.keyState[7] == 1:
-		# 	if o.note_bank < 3:
-		# 		o.note_bank += 1
+
+		if o.keyState[8] == 2:
+			if (o.repeater_states[8] != None and ((pygame.time.get_ticks() - o.repeater_states[8]) > 500)):
+				if o.volume > 0:
+					o.volume -= 1
+					text_center(o, "Master Volume", str(o.volume))
+					o.update_display(0)	
+				o.repeater_states[8] = pygame.time.get_ticks()
+
 		if o.keyState[8] == 1:
+			o.repeater_states[8] = pygame.time.get_ticks()
 			if o.volume > 0:
 				o.volume -= 1
 				text_center(o, "Master Volume", str(o.volume))
 				o.update_display(0)
+
+		if o.keyState[9] == 2:
+			if (o.repeater_states[9] != None and ((pygame.time.get_ticks() - o.repeater_states[9]) > 500)):
+				if o.volume < 16:
+					o.volume += 1
+					text_center(o, "Master Volume", str(o.volume))
+					o.update_display(0)
+				o.repeater_states[9] = pygame.time.get_ticks()
+
 		if o.keyState[9] == 1:
+			o.repeater_states[9] = pygame.time.get_ticks()
 			if o.volume < 16:
 				o.volume += 1
 				text_center(o, "Master Volume", str(o.volume))
 		if o.keyState[11] == 1:
 			#o.save_song()
 			pass
-		if o.keyState[14] == 1:
+
+		if o.keyState[10] == 2:
+			if (o.repeater_states[10] != None and ((pygame.time.get_ticks() - o.repeater_states[10]) > 500)):
+				if o.bpm > 60:
+					o.bpm = o.bpm - o.bpm_inc
+					o.update_bpm()
+					text_center(o, "Master BPM", str(o.bpm))
+					o.update_display(0)
+				o.repeater_states[10] = pygame.time.get_ticks()
+
+		if o.keyState[10] == 1:
+			o.repeater_states[10] = pygame.time.get_ticks()
 			if o.bpm > 60:
 				o.bpm = o.bpm - o.bpm_inc
 				o.update_bpm()
 				text_center(o, "Master BPM", str(o.bpm))
 				o.update_display(0)
-		if o.keyState[15] == 1:
+
+		if o.keyState[11] == 2:
+			if (o.repeater_states[11] != None and ((pygame.time.get_ticks() - o.repeater_states[11]) > 500)):
+				if o.bpm < 240:
+					o.bpm = o.bpm + o.bpm_inc
+					o.update_bpm()
+					text_center(o, "Master BPM", str(o.bpm))
+					o.update_display(0)
+				o.repeater_states[11] = pygame.time.get_ticks()
+
+		if o.keyState[11] == 1:
+			o.repeater_states[11] = pygame.time.get_ticks()
 			if o.bpm < 240:
 				o.bpm = o.bpm + o.bpm_inc
 				o.update_bpm()
 
 
 def menu2_actions_sample(self, o):
+	if o.keyState[6] == 4 or o.keyState[6] == 3:
+		print('reset repeat from menu')
+		o.button_repeater(1,[])
+
+	if o.keyState[7] == 4 or o.keyState[7] == 3:
+		print('reset repeat from menu')
+		o.button_repeater(1,[])
+
+	if o.keyState[8] == 4 or o.keyState[8] == 3:
+		print('reset repeat from menu')
+		o.button_repeater(1,[])
+
+	if o.keyState[9] == 4 or o.keyState[9] == 3:
+		print('reset repeat from menu')
+		o.button_repeater(1,[])
+
+	if o.keyState[10] == 4 or o.keyState[10] == 3:
+		print('reset repeat from menu')
+		o.button_repeater(1,[])
+
+	if o.keyState[11] == 4 or o.keyState[11] == 3:
+		print('reset repeat from menu')
+		o.button_repeater(1,[])
+
 	if o.keyState[17] == 2:
 		if o.keyState[0] == 1:
 			if o.soundSlots[o.eSound].volume > 0:
 				print('copy')
 				o.soundClipboard = [o.soundSlots[o.eSound].file, o.soundSlots[o.eSound].volume, o.soundSlots[o.eSound].pitch]
 				print(o.soundClipboard)
-				#text_center(o, "Sample Volume", str(o.soundSlots[o.eSound].volume))
-				#o.update_display(0)
-		elif o.keyState[1] == 1:
-			
-			print('pasting ', o.soundClipboard)
-			
-			o.soundSlots[o.eSound].file = o.soundClipboard[0]
-			o.soundSlots[o.eSound].volume = o.soundClipboard[1]
-			o.soundSlots[o.eSound].pitch = o.soundClipboard[2]
-			o.soundSlots[o.eSound].create_sound()
-			o.soundSlots[o.eSound].set_pitch()
-			
-			#s = o.SoundSlot(o.soundClipboard[0], o.eSound, o)
-			#s.volume = o.soundClipboard[1]
-			#s.pitch = o.soundClipboard[2]
-			#s.notes = s.init_notes()
-			#o.soundSlots[o.eSound] = s
+
+		if o.keyState[1] == 1:
+			if o.soundClipboard != []:
+				print('pasting ', o.soundClipboard)				
+				o.soundSlots[o.eSound].file = o.soundClipboard[0]
+				o.soundSlots[o.eSound].volume = o.soundClipboard[1]
+				o.soundSlots[o.eSound].pitch = o.soundClipboard[2]
+				o.soundSlots[o.eSound].create_sound()
+				o.soundSlots[o.eSound].set_pitch()
 			
-		elif o.keyState[2] == 1:
+		if o.keyState[2] == 1:
 			print('delete sound ', o.eSound)
 			o.soundSlots[o.eSound].file = None
 			o.soundSlots[o.eSound].volume = 16
 			o.soundSlots[o.eSound].pitch = 0
-		elif o.keyState[3] == 1:
+		if o.keyState[3] == 1:
 			print('load')
 			o.FSM.FSM.ToTransition("toLoadSound")
 
-		elif o.keyState[4] == 1:
+		if o.keyState[8] == 2:
+			if (o.repeater_states[8] != None and ((pygame.time.get_ticks() - o.repeater_states[8]) > 500)):
+				if o.soundSlots[o.eSound].volume > 0:
+					o.soundSlots[o.eSound].volume -= 1
+					text_center(o, "Sample Volume", str(o.soundSlots[o.eSound].volume))
+					o.update_display(0)	
+				o.repeater_states[8] = pygame.time.get_ticks()
+
+		if o.keyState[8] == 1:
 			if o.soundSlots[o.eSound].volume > 0:
 				o.soundSlots[o.eSound].volume -= 1
 				text_center(o, "Sample Volume", str(o.soundSlots[o.eSound].volume))
 				o.update_display(0)
+			o.repeater_states[8] = pygame.time.get_ticks()
 
-		elif o.keyState[5] == 1:
+		if o.keyState[9] == 2:
+			if (o.repeater_states[9] != None and ((pygame.time.get_ticks() - o.repeater_states[9]) > 500)):
+				if o.soundSlots[o.eSound].volume < 16:
+					o.soundSlots[o.eSound].volume += 1
+					text_center(o, "Sample Volume", str(o.soundSlots[o.eSound].volume))
+					o.update_display(0)
+				o.repeater_states[9] = pygame.time.get_ticks()
+
+		if o.keyState[9] == 1:
 			if o.soundSlots[o.eSound].volume < 16:
 				o.soundSlots[o.eSound].volume += 1
 				text_center(o, "Sample Volume", str(o.soundSlots[o.eSound].volume))
 				o.update_display(0)
+			o.repeater_states[9] = pygame.time.get_ticks()
 
-		elif o.keyState[6] == 1:
+		if o.keyState[6] == 2:
+			if (o.repeater_states[6] != None and ((pygame.time.get_ticks() - o.repeater_states[6]) > 500)):
+				if o.note_bank > 0:
+					o.note_bank -= 1
+					text_center(o, "Sound Bank", str(o.note_bank))
+					o.update_display(0)
+				o.repeater_states[6] = pygame.time.get_ticks()
+
+		if o.keyState[6] == 1:
 			if o.note_bank > 0:
 				o.note_bank -= 1
 				text_center(o, "Sound Bank", str(o.note_bank))
+				o.repeater_states[6] = pygame.time.get_ticks()
 				o.update_display(0)
-		elif o.keyState[7] == 1:
+
+		if o.keyState[7] == 2:
+			if (o.repeater_states[7] != None and ((pygame.time.get_ticks() - o.repeater_states[7]) > 500)):
+				if o.note_bank < 3:
+					o.note_bank += 1
+					text_center(o, "Sound Bank", str(o.note_bank))
+					o.update_display(0)
+				o.repeater_states[7] = pygame.time.get_ticks()
+
+		if o.keyState[7] == 1:
 			if o.note_bank < 3:
 				o.note_bank += 1
 				text_center(o, "Sound Bank", str(o.note_bank))
+				o.repeater_states[7] = pygame.time.get_ticks()
 				o.update_display(0)
 
-		elif o.keyState[8] == 1:
+		if o.keyState[10] == 2:
+			if (o.repeater_states[10] != None and ((pygame.time.get_ticks() - o.repeater_states[10]) > 500)):
+				if o.soundSlots[o.eSound].pitch > -10:
+					o.soundSlots[o.eSound].pitch -= 1
+					text_center(o, "Sample Pitch", str(o.soundSlots[o.eSound].pitch))
+					o.soundSlots[o.eSound].set_pitch()
+					o.update_display(0)
+				o.repeater_states[10] = pygame.time.get_ticks()
+
+
+		if o.keyState[10] == 1:
 			if o.soundSlots[o.eSound].pitch > -10:
 				o.soundSlots[o.eSound].pitch -= 1
 				text_center(o, "Sample Pitch", str(o.soundSlots[o.eSound].pitch))
 				o.soundSlots[o.eSound].set_pitch()
+				o.repeater_states[10] = pygame.time.get_ticks()
 				o.update_display(0)
-		elif o.keyState[9] == 1:
+
+		if o.keyState[11] == 2:
+			if (o.repeater_states[11] != None and ((pygame.time.get_ticks() - o.repeater_states[11]) > 500)):
+				if o.soundSlots[o.eSound].pitch < 10:
+					o.soundSlots[o.eSound].pitch += 1
+					text_center(o, "Sample Pitch", str(o.soundSlots[o.eSound].pitch))
+					o.soundSlots[o.eSound].set_pitch()
+					o.update_display(0)
+				o.repeater_states[11] = pygame.time.get_ticks()
+
+
+		if o.keyState[11] == 1:
 			if o.soundSlots[o.eSound].pitch < 10:
 				o.soundSlots[o.eSound].pitch += 1
 				text_center(o, "Sample Pitch", str(o.soundSlots[o.eSound].pitch))
 				o.soundSlots[o.eSound].set_pitch()
+				o.repeater_states[11] = pygame.time.get_ticks()
 				o.update_display(0)
-		elif o.keyState[12] == 1:
+
+		if o.keyState[12] == 1:
 			o.odub = not o.odub
 			o.undo_buf = []
 			print('odub now is ', o.odub)
 			draw_menu2_sample(o)
 			o.update_display(0)
-		elif o.keyState[13] == 1:
+
+		if o.keyState[13] == 1:
 			print('undo something')
 			for i in o.undo_buf:
 				o.soundSlots[i[0]].notes[i[1]][i[2]][0] = 0
 				notes = []
 				for i in s.notes[o.ePattern]:
 					notes.append([i[0], i[1]])
-					#i[0] = 0
-					#i[1] = 0
 				o.patternClipboard.append(notes)
 				print('adding to clip ', notes)
-			# if o.soundSlots[o.eSound].volume > 0:
-			# 	o.soundSlots[o.eSound].volume -= 1
-			# 	text_center(o, "Sample Volume", str(o.soundSlots[o.eSound].volume))
-			# 	o.update_display(0)
+			
 		elif o.keyState[1] == 1:
 			print('paste')
 			if o.patternClipboard != []:
 						n += 1
 					print('added ', o.patternClipboard[p])
 					p += 1
-					
-				
 			else:
 				print('nothing to paste')
-			# if o.soundSlots[o.eSound].volume < 16:
-			# 	o.soundSlots[o.eSound].volume += 1
-			# 	text_center(o, "Sample Volume", str(o.soundSlots[o.eSound].volume))
-			# 	o.update_display(0)
+			
 		elif o.keyState[2] == 1:
 			print('clear')
 			print(o.soundSlots[o.eSound].notes[o.ePattern])
 				for i in s.notes[o.ePattern]:
 					i[0] = 0
 					i[1] = 0
-			#print(o.soundSlots[o.eSound].notes[o.ePattern])
-			# if o.soundSlots[o.eSound].pitch > -10:
-			# 	o.soundSlots[o.eSound].pitch -= 1
-			# 	text_center(o, "Sample Pitch", str(o.soundSlots[o.eSound].pitch))
-			# 	o.soundSlots[o.eSound].set_pitch()
-			# 	o.update_display(0)
+			
 		elif o.keyState[6] == 1:
 			if o.pat_bank > 0:
 				o.pat_bank -= 1
 				
 
 def menu2_actions_note(self, o):
+	if o.keyState[8] == 4 or o.keyState[8] == 3:
+		print('reset repeat from menu')
+		o.button_repeater(1,[])
+
+	if o.keyState[9] == 4 or o.keyState[9] == 3:
+		print('reset repeat from menu')
+		o.button_repeater(1,[])
+
 	if o.keyState[17] == 2:
-		if o.keyState[0] == 1:
+		
+
+		if o.keyState[8] == 2:
+			if (o.repeater_states[8] != None and ((pygame.time.get_ticks() - o.repeater_states[8]) > 500)):
+				if o.note_vol > 0:
+					o.note_vol -= 1
+					text_center(o, "Note Volume", str(o.note_vol))
+					o.update_display(0)		
+				o.repeater_states[8] = pygame.time.get_ticks()
+
+		if o.keyState[8] == 1:
 			if o.note_vol > 0:
 				o.note_vol -= 1
 				text_center(o, "Note Volume", str(o.note_vol))
+				o.repeater_states[8] = pygame.time.get_ticks()
 				o.update_display(0)		
 
-		elif o.keyState[1] == 1:
+		if o.keyState[9] == 2:
+			if (o.repeater_states[9] != None and ((pygame.time.get_ticks() - o.repeater_states[9]) > 500)):
+				if o.note_vol < 16:
+					o.note_vol += 1
+					text_center(o, "Note Volume", str(o.note_vol))					
+					o.update_display(0)
+				o.repeater_states[9] = pygame.time.get_ticks()
+
+		if o.keyState[9] == 1:
 			if o.note_vol < 16:
 				o.note_vol += 1
 				text_center(o, "Note Volume", str(o.note_vol))
+				o.repeater_states[9] = pygame.time.get_ticks()
 				o.update_display(0)
-		elif o.keyState[12] == 1:
+
+		if o.keyState[12] == 1:
 			if o.patternFollow:
 				o.patternFollow = False
 			else:
 				o.patternFollow = True
-			#o.patternFollow != o.patternFollow
+
 			print('pattern follow is ', o.patternFollow)
 			draw_menu2_note(o)
-			o.update_display(0)	
-			
-			
-		
+			o.update_display(0)			
 					
 
 def util_command(self, o, command):
 		self.FSM.ToTransition('toBall')		
 	elif command == "Defender":
 		self.FSM.ToTransition('toDefender')	
+	elif command == "Calculator":
+		self.FSM.ToTransition('toCalculator')	
+
 	elif command == "Exit":
 		self.FSM.ToTransition('toExit')		
 	elif command == "Theme":
 		
 	def Execute(self):
 		o = self.FSM.owner 
+		
+		# if o.keyState[16] == 2:
+		# 	o.button_repeater(0, [8,9,14,15])
+
+		#if o.keyState[17] == 2:
+		#	o.button_repeater(0, [4,5,6,7,8,9])
+
 		menu1_actions(self, o)
 		menu2_actions_sample(self, o)
 		#self.FSM.ToTransition('toClock')
 			text_box2(o, "BPM", str(o.bpm))
 			text_box4(o, "Bank", str(o.note_bank))
 			text_box3(o, "Pitch", str(o.soundSlots[o.eSound].pitch))
+			o.button_repeater(1, [])
 			o.update_display(0)
 
+		
+
 
 		if o.keyState[17] == 1:
 			draw_menu2_sample(o)
 		o = self.FSM.owner 
 		o.header_text = "Utilities"
 		o.pub.register("beat", self)
-		self.menu = ["Clock", "Balls", "Defender", "Exit", "Shutdown", "Reboot", "Theme", "Ping", "Wifi", "Update"]
+		self.menu = ["Clock", "Balls", "Defender", "Calculator", "Exit", "Shutdown", "Reboot", "Theme", "Ping", "Wifi", "Update"]
 		self.cur_el = 0
 
 		if o.keyState[16] > 0 or o.keyState[17] > 0:
 		super(Defender, self).__init__(FSM)    
 		
 	def Enter(self):
-		self.ball_size = 10
-		self.ballx = self.ball_size
-		self.bally = self.ball_size
-		
-		self.ball_speed = 8
-		self.ball_x_dir = 1
-		self.ball_y_dir = 1
+		o = self.FSM.owner 
 		
-		self.ball2x = self.ball_size + 180
-		self.ball2y = self.ball_size + 70
-	
-		self.ball2_x_dir = -1
-		self.ball2_y_dir = -1
-
-		self.xmult = 1.0
+		self.gameFSM = FSM.DefenderFSM(o)
 
-		o = self.FSM.owner 
-		o.header_text = "Balls"
-		o.pub.register("beat", self)
-		if o.keyState[16] > 0 or o.keyState[17] > 0:
-			pass
-		else:
-			draw_header(o)
-			o.update_display(0)
 		super(Defender, self).Enter()        
 		
 	def Execute(self):
 		if o.keyState[16] == 1:
 			draw_menu1(o)
 			o.update_display(0)
-		
-
-		if o.keyState[16] > 0 or o.keyState[17] > 0:
+		elif o.keyState[16] == 4:
+			#draw_header(o)
+			#self.draw_footer(o)
+			#self.draw_main(o)
+			#o.update_display(0)		
 			pass
-		else:			
-			now = datetime.now()
-			current_time = time.strftime("%-I:%M %p")
-
-
-			if self.ballx < (0 + self.ball_size):
-				self.ball_x_dir = 1
-			if self.ballx > (o.width - self.ball_size):
-				self.ball_x_dir = -1
-
-			if self.bally < (0 + self.ball_size):
-				self.ball_y_dir = 1
-			if self.bally > (o.height - self.ball_size):
-				self.ball_y_dir = -1
-
-			# if self.ballx > (o.width - self.ball_size) or self.ballx < (0 + self.ball_size):
-			# 	self.ball_x_dir *= -1
-			# if self.bally > (o.height - self.ball_size) or self.bally < (0 + self.ball_size):
-			# 	self.ball_y_dir *= -1
-
-			self.ballx += self.ball_speed * self.ball_x_dir
-			self.bally += self.ball_speed * self.ball_y_dir
-
-
-			if self.ball2x < (0 + self.ball_size):
-				self.ball2_x_dir = 1
-				self.xmult = random.uniform(.6, 1.2)
-			if self.ball2x > (o.width - self.ball_size):
-				self.ball2_x_dir = -1
-				self.xmult = random.uniform(.6, 1.2)
-
-			if self.ball2y < (0 + self.ball_size):
-				self.ball2_y_dir = 1
-			if self.ball2y > (o.height - self.ball_size):
-				self.ball2_y_dir = -1			
-
-
-			# if self.ball2x > (o.width - self.ball_size) or self.ball2x < (0 + self.ball_size):
-			# 	self.ball2_x_dir *= -1
-			# 	self.xmult = random.uniform(.8, 1.2)
-			# if self.ball2y > (o.height - self.ball_size) or self.ball2y < (0 + self.ball_size):
-			# 	self.ball2_y_dir *= -1
 
-			self.ball2x += (self.ball_speed * self.ball2_x_dir) * self.xmult
-			self.ball2y += (self.ball_speed * self.ball2_y_dir) 
+		if o.keyState[16] > 0 or o.keyState[17] > 0:
 
-			o.draw.rectangle((0, 0, o.width, o.height), outline=0, fill=o.blue)
-			
-			o.draw.ellipse((self.ballx - self.ball_size, self.bally - self.ball_size, self.ballx + self.ball_size, self.bally + self.ball_size), fill = o.light_grey, outline =o.light_grey)
-			o.draw.ellipse((self.ball2x - self.ball_size, self.ball2y - self.ball_size, self.ball2x + self.ball_size, self.ball2y + self.ball_size), fill = o.light_grey, outline =o.light_grey)
-			#o.center_block(current_time, o.h3, [0,0,o.width,o.height], o.pink)
-			o.update_display(0)
-		
-	def ReceiveMessage(self, message):
-		o = self.FSM.owner 
-		play_seq(o, message)
+		#if o.keyState[16] > 0:
+			pass
+		else:
+			self.gameFSM.Execute()
 		
 	def Exit(self):
-		self.FSM.owner.pub.unregister("beat", self)        
+		pass
 
 #==================================== 
 #==================================== 
 		self.FSM.owner.pub.unregister("beat", self)        
 
 #==================================== 
+
+
+
+class Calculator(State):
+	def __init__(self,FSM):
+		super(Calculator, self).__init__(FSM)    
+		
+	def Enter(self):
+		o = self.FSM.owner 
+
+		o.pub.register("beat", self)
+		
+		self.num1 = ''
+		self.num2 = ''
+		self.op = ''
+		self.result = ''
+
+		self.labels = ['.', '0', '=', '/',
+						'1', '2', '3', '*',
+						'4', '5', '6', '-',
+						'7', '8', '9', '+',
+						'7', '8', '9', '+']
+
+		self.draw_main(o)
+		o.update_display(0)
+		print('hi calc')
+
+		super(Calculator, self).Enter()        
+		
+	def Execute(self):
+		o = self.FSM.owner 
+		menu1_actions(self, o)
+		if o.keyState[16] == 1:
+			draw_menu1(o)
+			o.update_display(0)
+		elif o.keyState[16] == 4:		
+			self.draw_main(o)
+			o.update_display(0)
+
+		if o.keyState[16] > 0:
+			pass
+		else:
+			#pass
+		
+			if o.keyState[17] == 1:
+				self.num1 = ''
+				self.num2 = ''
+				self.op = ''
+				self.result = ''
+
+			self.check_keys(o)
+
+	def append_num(self, num):
+		ops = ['+', '-', '*', '/']
+		print('appending num ', num)
+		if num in ops:
+			if self.num1 != '':
+				self.op = num
+		elif num == '=':
+			print('this is that')
+			if self.num2 != '':
+				if self.op == '+':
+					self.result = float(self.num1) + float(self.num2)
+					print(self.result)
+				if self.op == '-':
+					self.result = float(self.num1) - float(self.num2)
+					print(self.result)
+				if self.op == '*':
+					self.result = float(self.num1) * float(self.num2)
+					print(self.result)
+				if self.op == '/':
+					self.result = float(self.num1) / float(self.num2)
+					print(self.result)
+
+		else:
+			if self.result != '':
+				self.num1 = ''
+				self.num2 = ''
+				self.op = ''
+				self.result = ''
+			if self.op == '':
+				self.num1 += num
+				print('---append ', num)
+			else:
+				self.num2 += num
+				print('---append ', num)
+	def check_keys(self, o):
+		_iter = 0
+		for k in o.keyState:
+			if k == 1:
+				if _iter == 0:
+					if ('.' not in self.num1 and self.num2 == '') or (self.num2 != '' and '.' not in self.num2):
+						self.append_num('.')
+				if _iter == 1:
+					self.append_num('0')
+				if _iter == 2:
+					self.append_num('=')
+				if _iter == 3:
+					self.append_num('/')
+				if _iter == 4:
+					self.append_num('1')
+				if _iter == 5:
+					self.append_num('2')
+				if _iter == 6:
+					self.append_num('3')
+				if _iter == 7:
+					self.append_num('*')
+				if _iter == 8:
+					self.append_num('4')
+				if _iter == 9:
+					self.append_num('5')
+				if _iter == 10:
+					self.append_num('6')
+				if _iter == 11:
+					self.append_num('-')
+				if _iter == 12:
+					self.append_num('7')
+				if _iter == 13:
+					self.append_num('8')
+				if _iter == 14:
+					self.append_num('9')
+				if _iter == 15:
+					self.append_num('+')
+
+				self.draw_main(o)
+
+			_iter += 1
+
+	def draw_main(self, o):
+		print('drawing ', self.num1)
+		x_size = o.width / 4
+		y_size = o.height / 5
+		og_x = 0
+		o_x = og_x
+		o_y = o.height
+		text_padding = 6
+		
+		_id = 0
+		while _id < 20:
+			# lab = ""
+			# for i in self.labels[_id]:
+			# 	lab += i
+
+			lab = self.labels[_id]
+
+			o.draw.rectangle((o_x, o_y, o_x + x_size, o_y - y_size), outline=0, fill=o.blue)
+			o.center_block(lab, o.h2, [o_x, o_y, o_x + x_size, o_y - y_size], o.light_grey)
+
+			o_x = o_x + x_size
+			_id += 1
+			if _id % 4 == 0:
+				o_y -= y_size
+				o_x = og_x
+		o.draw.rectangle((0, 0, o.width, y_size), outline=0, fill=o.blue)
+		#o.center_block('where is my fucking text', o.h2, [0, 0, o.width, y_size], o.light_grey)
+		if self.num1 != '':
+			if self.result != '':
+				o.center_block(str(self.result), o.h2, [0, 0, o.width, y_size], o.light_grey)
+			elif self.num2 != '':
+				o.center_block(str(self.num2), o.h2, [0, 0, o.width, y_size], o.light_grey)
+			elif self.op != '':
+				o.center_block(str(self.op), o.h2, [0, 0, o.width, y_size], o.light_grey)
+			else:
+				o.center_block(str(self.num1), o.h2, [0, 0, o.width, y_size], o.light_grey)
+			print('fucking do something')
+		else:
+			print('num1 is empty')
+		o.update_display(0)
+
+	def ReceiveMessage(self, message):
+		o = self.FSM.owner 
+		play_seq(o, message)
+
+	def Exit(self):
+		self.FSM.owner.pub.unregister("beat", self)
+
+#==================================== 

main.py

 		self.notes_on = []
 		self.clear_notes_on()
 
+		self.press_ticks_up = None
+		self.press_ticks_down = None
 
 		self.pub = observer.Publisher(['beat', 'the joint'])
+		self.repeater_states = []
+		_iter = 0
+		while _iter < 18:
+			self.repeater_states.append(None)
+			_iter += 1
 
 		#self.song_file_name = "default.sng"
 		self.mconf = ConfigObj("config.txt")
 			elif self.keyState[17] == 4:
 				self.keyState[17] = 0
 
+	def button_repeater(self, state, enables):
+		if state == 0:
+			pass
+			# _iter = 0
+			# for b in self.keyState:
+			# 	if _iter in enables:
+			# 		if b == 2:
+			# 			if self.repeater_states[_iter] == None:
+			# 				#self.repeater_states[_iter] = pygame.time.get_ticks()
+			# 				pass
+			# 			else:
+			# 				t = pygame.time.get_ticks() - self.repeater_states[_iter]
+			# 				if t > 250:
+			# 					#self.repeater_states[_iter] = pygame.time.get_ticks()	
+			# 					#b = 0
+			# 					print('new tick ', _iter, ' ', b)
+
+			# 	_iter += 1
+			#self.repeater_states
+		elif state == 1:
+			for i in self.repeater_states:
+				i = None
+			print('reset repeater')
+
 	def update_bpm(self):
 		bpm = (60000 / self.bpm) / 4
 		self.half_bpm = bpm / 2