API tools faq
paste
Advertisement
beezing

Flappy Bee - Pythonista

beezing
Mar 12th, 2014
189
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 12.36 KB | None | 0 0
raw download clone embed print report
  1. from scene import *
  2. from PIL import Image
  3. import sound
  4. import random
  5.  
  6. GAME_READY = 0
  7. GAME_PLAY = 1
  8. GAME_DYING = 2
  9. GAME_DEAD = 3
  10.  
  11. FLOOR_IMGS = ['Ear_Of_Rice', 'Herb', 'Snail', 'Spiral_Shell', 'Turtle', 'Anchor', 'Pile_Of_Poo', 'Sailboat', 'Speedboat']
  12. BACK_IMGS = ['Blowfish', 'Dolphin', 'Fish', 'Tropical_Fish', 'Whale']
  13.  
  14. class GameEnvironment(object):
  15.     def __init__(self, x, y, w, h):
  16.         self.playfield = Rect(x, y, w, h)
  17.         self.gravity =              int(h *-3.000)          # 3000
  18.         self.scroll =               int(h * 0.300)          # 300
  19.         self.float_max =            int(h * 0.300)          # 300
  20.         self.float_min =      int(h * 0.050)            # 50
  21.         self.jump =                     int(h * 0.800)          # 800
  22.         self.gap =                      int(h * 0.400)          # 360
  23.         self.ground_height =  int(h * 0.100)            # 100
  24.         self.tower_width =    int(h * 0.140)            # 140
  25.         self.tower_cap =            int(h * 0.065)          # 65
  26.         self.tower_gap = (self.playfield.w - (self.tower_width))
  27.         self.tower_min_height = self.tower_cap
  28.         self.tower_max_height = self.playfield.h - self.ground_height - self. tower_cap - self.tower_gap
  29.         self.player_width =     int(h * 0.080)          # 80
  30.         self.player_height =    int(h * 0.080)          # 80
  31.         self.player_x =             int(h * 0.200)          # 200
  32.         self.player_y = self.playfield.h / 2 + self.ground_height
  33.         self.bubble_min =       int(h * 0.002)          # 2
  34.         self.bubble_max =       int(h * 0.020)          # 20
  35.         self.floor_min =        int(h * 0.040)          # 40
  36.         self.floor_max =        int(h * 0.128)          # 128
  37.         self.back_min =             int(h * 0.020)          # 20
  38.         self.back_max =             int(h * 0.040)          # 40
  39.         self.text_x = w / 2
  40.         self.text_1_y = 0.9 * h
  41.         self.text_2_y = 0.6 * h
  42.         self.text_3_y = 0.4 * h
  43.         self.font_size =        int(h * 0.064)          #  64
  44.         self.font = 'AvenirNext-Heavy'
  45.         self.score = 0
  46.         self.best = 0
  47.         self.crash = False
  48.         self.gametime = 0
  49.         self.deadtime = 0
  50.         self.state = GAME_READY
  51.        
  52. class Bubble(object):
  53.     def __init__(self, x, y, w, h, float):
  54.         self.bounds = Rect(x, y, w, h)
  55.         self.float = float
  56.         self.alpha = random.random()
  57.         self.img = 'White_Circle'
  58.        
  59.     def draw(self):
  60.         tint(1, 1, 1, self.alpha)
  61.         image(self.img, self.bounds.x, self.bounds.y, self.bounds.w, self.bounds.h)
  62.        
  63. class Player(object):
  64.     def __init__(self, x, y, w, h):
  65.         self.bounds = Rect(x, y, w, h)
  66.         img = Image.open('Honeybee').transpose(Image.FLIP_LEFT_RIGHT)
  67.         self.img = load_pil_image(img)
  68.         self.velocity = 0
  69.         self.jumped = False
  70.        
  71.     def draw(self):
  72.         tint(1.00, 1.00, 1.00)
  73.         image(self.img, self.bounds.x, self.bounds.y, self.bounds.w, self.bounds.h)
  74.        
  75. class FloorSprite(object): 
  76.     def __init__(self, env):
  77.         self.env = env
  78.         self.set_random_bounds()
  79.         self.set_random_image()
  80.        
  81.     def set_random_image(self):
  82.         img = Image.open(FLOOR_IMGS[random.randint(0, len(FLOOR_IMGS) - 1)])
  83.         if(random.random > 0.5):
  84.             img = img.transpose(Image.FLIP_LEFT_RIGHT)
  85.         self.img = load_pil_image(img)
  86.  
  87.     def set_random_bounds(self):
  88.         env = self.env
  89.         size = random.randint(env.floor_min, env.floor_max)
  90.         y = random.randint(env.playfield.bottom(), env.ground_height)
  91.         x = random.randint(env.playfield.left(), env.playfield.right() + env.playfield.w)
  92.         self.bounds = Rect(x, y, size, size)
  93.        
  94.     def draw(self):
  95.         tint(1,1,1)
  96.         image(self.img, self.bounds.x, self.bounds.y, self.bounds.w, self.bounds.h)
  97.        
  98. class BackgroundSprite(object):
  99.     def __init__(self, env):
  100.         self.env = env
  101.         self.velocity = env.scroll / 4
  102.         self.set_random_bounds()
  103.         self.set_random_image()
  104.  
  105.     def set_random_image(self):
  106.         img = Image.open(BACK_IMGS[random.randint(0, len(BACK_IMGS) - 1)])
  107.         self.velocity = random.randint(self.env.scroll / 4, self.env.scroll / 2)
  108.         if(random.random() > 0.5):
  109.             img = img.transpose(Image.FLIP_LEFT_RIGHT)
  110.             self.velocity *= -1
  111.         self.img = load_pil_image(img)
  112.  
  113.     def set_random_bounds(self):
  114.         env = self.env
  115.         size = random.randint(env.back_min, env.back_max)
  116.         y = random.randint(env.ground_height, env.playfield.top() - size)
  117.         if self.velocity < 0:
  118.             x = env.playfield.left()
  119.         else:
  120.             x = env.playfield.right()
  121.         self.bounds = Rect(x, y, size, size)
  122.        
  123.     def draw(self):
  124.         tint(1,1,1)
  125.         image(self.img, self.bounds.x, self.bounds.y, self.bounds.w, self.bounds.h)
  126.                
  127. class Ground(object):
  128.     def __init__(self, x, y, w, h):
  129.         self.bounds = Rect(x, y, w, h)
  130.    
  131.     def draw(self):
  132.         stroke_weight(4)
  133.         stroke(0.00, 0.00, 0.00)
  134.         fill(0.50, 0.25, 0.00)
  135.         rect(self.bounds.x, self.bounds.y, self.bounds.w, self.bounds.h)
  136.        
  137. class Tower(object):
  138.     def __init__(self, x, env):
  139.         self.x = x
  140.         self.env = env
  141.         self.create_towers_and_caps()
  142.        
  143.     def set_x(self, x):
  144.         self.x = x
  145.         self.lower_tower.x = x + 6
  146.         self.lower_cap.x = x
  147.         self.upper_tower.x = x + 6
  148.         self.upper_cap.x = x
  149.        
  150.     def right(self):
  151.         return self.lower_tower.right()
  152.    
  153.     def left(self):
  154.         return self.lower_tower.left()
  155.        
  156.     def create_towers_and_caps(self):
  157.         self.passed = False
  158.         height = random.randint(self.env.tower_min_height, self.env.tower_max_height)
  159.         self.lower_tower = Rect(self.x + 6, self.env.ground_height, self.env.tower_width - 12, height)
  160.         self.lower_cap = Rect(self.x, self.env.ground_height + height - self.env.tower_cap, self.env.tower_width, self.env.tower_cap)
  161.         self.upper_tower =  Rect(self.x + 6, height + self.env.gap, self.env.tower_width - 12, self.env.playfield.h - height + self.env.gap)
  162.         self.upper_cap = Rect(self.x, height + self.env.gap, self.env.tower_width, self.env.tower_cap)
  163.        
  164.     def intersects(self, r):
  165.         return self.lower_tower.intersects(r) or self.upper_tower.intersects(r)
  166.        
  167.     def draw(self):
  168.         stroke_weight(4)
  169.         stroke(0.00, 0.50, 0.25)
  170.         stroke(0.20, 0.20, 0.00)
  171.         fill(0.00, 1.00, 0.00)
  172.         fill(0.50, 0.50, 0.00)
  173.         rect(self.lower_tower.x, self.lower_tower.y, self.lower_tower.w, self.lower_tower.h)
  174.         rect(self.lower_cap.x, self.lower_cap.y, self.lower_cap.w, self.lower_cap.h)
  175.         rect(self.upper_tower.x, self.upper_tower.y, self.upper_tower.w, self.upper_tower.h)
  176.         rect(self.upper_cap.x, self.upper_cap.y, self.upper_cap.w, self.upper_cap.h)
  177.  
  178. class Game(object):
  179.     def __init__(self, x, y, w, h):
  180.         self.env = GameEnvironment(x, y, w, h)
  181.         self.game_setup()
  182.        
  183.     def game_setup(self):
  184.         self.env.score = 0
  185.         self.env.crash = False
  186.         self.env.state = GAME_READY
  187.         self.create_game_objects()
  188.        
  189.     def create_game_objects(self):
  190.         self.player = Player(self.env.player_x, self.env.player_y, self.env.player_width, self.env.player_height)
  191.         self.ground = Ground(self.env.playfield.x, self.env.playfield.y, self.env.playfield.w, self.env.ground_height)
  192.         self.towers = []
  193.         x = self.env.playfield.w * 2
  194.         for t in range(2):
  195.             self.towers.append(Tower(x, self.env))
  196.             x += self.env.tower_width + self.env.tower_gap
  197.         self.bubbles = []
  198.         for t in range(10):
  199.             d = random.randint(0, 20)
  200.             self.bubbles.append(Bubble(random.randint(0, self.env.playfield.w), random.randint(0, self.env.playfield.h), d, d,random.randint(self.env.float_min, self.env.float_max)))
  201.         self.floor_sprites = []
  202.         for t in range(1):
  203.             self.floor_sprites.append(FloorSprite(self.env))
  204.         self.background_sprites = []
  205.         for t in range(2):
  206.             self.background_sprites.append(BackgroundSprite(self.env))
  207.            
  208.     def move_player(self, dt):
  209.         if(self.env.state == GAME_DEAD):
  210.             return
  211.         elif((self.env.state == GAME_READY) and (self.player.bounds.y < (self.env.playfield.h / 2)) or self.player.jumped):
  212.             self.player.jumped = False
  213.             self.player.velocity = self.env.jump
  214.         else:
  215.             self.player.velocity = self.player.velocity + self.env.gravity * dt
  216.         self.player.bounds.y += self.player.velocity * dt
  217.        
  218.     def move_towers(self, dt):
  219.         if(self.env.state == GAME_PLAY):
  220.             move = self.env.scroll * dt
  221.             for tower in self.towers:
  222.                 tower.set_x(tower.x - move)
  223.                 if tower.right() < self.env.playfield.x:
  224.                     tower.set_x(self.env.playfield.w + self.env.tower_gap)
  225.                     tower.create_towers_and_caps()
  226.                
  227.     def move_bubbles(self, dt):
  228.         if(self.env.state == GAME_DEAD):
  229.             return
  230.         for bubble in self.bubbles:
  231.             if (bubble.bounds.bottom() > self.env.playfield.top()) or (bubble.bounds.left() < self.env.playfield.left()):
  232.                 x = random.randint(self.env.playfield.left(), self.env.playfield.right() + self.env.playfield.w)
  233.                 y = self.env.playfield.bottom() - random.randint(0, self.env.bubble_max)
  234.                 d = random.randint(self.env.bubble_min, self.env.bubble_max)
  235.                 bubble.bounds = Rect(x, y, d, d)
  236.                 bubble.float = random.randint(self.env.float_min, self.env.float_max)
  237.             bubble.bounds.y += bubble.float * dt
  238.             if(self.env.state <> GAME_DYING):
  239.                 bubble.bounds.x -= self.env.scroll * dt
  240.                
  241.     def move_floor_sprites(self, dt):
  242.         if(self.env.state == GAME_READY) or (self.env.state == GAME_PLAY):
  243.             move = self.env.scroll * dt
  244.             for sprite in self.floor_sprites:
  245.                 sprite.bounds.x -= move
  246.                 if sprite.bounds.right() < self.env.playfield.left():
  247.                     sprite.set_random_image()
  248.                     sprite.set_random_bounds()
  249.                     sprite.bounds.x = random.randint(self.env.playfield.right(), self.env.playfield.right() + self.env.playfield.w)
  250.                    
  251.     def move_background_sprites(self, dt):
  252.         if(self.env.state == GAME_READY) or (self.env.state == GAME_PLAY):
  253.             for sprite in self.background_sprites:
  254.                 move = sprite.velocity * dt
  255.                 sprite.bounds.x -= move
  256.                 if(sprite.bounds.right() < self.env.playfield.left()) or (sprite.bounds.left() > self.env.playfield.right()):
  257.                     sprite.set_random_image()
  258.                     sprite.set_random_bounds()
  259.  
  260.     def update_score(self):
  261.         if(self.env.state == GAME_PLAY):
  262.             for tower in self.towers:
  263.                 if tower.passed == False:
  264.                     if tower.left() < self.player.bounds.right():
  265.                         tower.passed = True
  266.                         self.env.score += 1
  267.                         sound.play_effect('Coin_1')
  268.                        
  269.     def player_dead(self):
  270.         self.env.state = GAME_DEAD
  271.         self.env.dead_time = self.env.game_time
  272.         if self.env.score > self.env.best:
  273.             self.env.best = self.env.score
  274.    
  275.     def collision_detect(self):
  276.         if(self.env.state == GAME_PLAY):
  277.             if self.player.bounds.bottom() < self.ground.bounds.top():
  278.                 sound.play_effect('Crashing')
  279.                 self.env.crash = True
  280.                 self.player_dead()
  281.         elif(self.env.state == GAME_DYING):
  282.             if self.player.bounds.bottom() < self.ground.bounds.top():
  283.                 self.player_dead()         
  284.         if self.env.state == GAME_PLAY:
  285.             if self.player.bounds.bottom() >  self.env.playfield.top():
  286.                     self.env.crash = True
  287.                     self.env.state = GAME_DYING
  288.             else:
  289.                 for tower in self.towers:
  290.                     if tower.intersects(self.player.bounds):
  291.                         sound.play_effect('Crashing')
  292.                         self.env.crash = True
  293.                         self.env.state = GAME_DYING
  294.                    
  295.     def text_shadow(self, s, y):
  296.         tint(0, 0, 0)
  297.         text(s, self.env.font, self.env.font_size, self.env.text_x + 4, y - 4)
  298.         tint(1, 1, 1)
  299.         text(s, self.env.font, self.env.font_size, self.env.text_x, y)
  300.                    
  301.     def draw(self):
  302.         if(self.env.crash):
  303.             background(1, 1, 1)
  304.             self.env.crash = False
  305.         else:
  306.             background(0.00, 0.50, 0.50)
  307.             for bubble in self.bubbles:
  308.                 bubble.draw()  
  309.             for sprite in self.background_sprites:
  310.                 sprite.draw()
  311.             self.ground.draw()
  312.             for tower in self.towers:
  313.                 tower.draw()
  314.             self.player.draw()
  315.             for sprite in self.floor_sprites:
  316.                 sprite.draw()
  317.             tint(0, 0, 0)
  318.             if(self.env.state == GAME_READY):
  319.                 self.text_shadow('Flappy Bee', self.env.text_1_y)
  320.                 self.text_shadow('Tap to Start!', self.env.text_2_y)
  321.             elif((self.env.state == GAME_PLAY) or (self.env.state == GAME_DYING) or (self.env.state == GAME_READY)):
  322.                 self.text_shadow(str(int(self.env.score)), self.env.text_1_y)
  323.             elif(self.env.state == GAME_DEAD):
  324.                 self.text_shadow('Flappy Bee', self.env.text_1_y)
  325.                 self.text_shadow('Score : ' + str(int(self.env.score)), self.env.text_2_y)
  326.                 self.text_shadow('Best  : ' + str(int(self.env.best)), self.env.text_3_y)
  327.                
  328.     def loop(self, dt, t):
  329.         self.env.game_time = t
  330.         self.move_player(dt)
  331.         self.move_towers(dt)
  332.         self.move_bubbles(dt)
  333.         self.move_floor_sprites(dt)
  334.         self.move_background_sprites(dt)
  335.         self.update_score()
  336.         self.collision_detect()
  337.         self.draw()
  338.        
  339.     def screen_tapped(self):
  340.         if(self.env.state == GAME_READY):
  341.             self.env.state = GAME_PLAY
  342.         if(self.env.state == GAME_PLAY):
  343.             self.player.jumped = True
  344.             sound.play_effect('Boing_1')
  345.         elif(self.env.state == GAME_DEAD):
  346.             if(self.env.dead_time + 0.5 < self.env.game_time):
  347.                 self.game_setup()          
  348.  
  349. class MyScene (Scene):
  350.     def setup(self):
  351.         self.game = Game(self.bounds.x, self.bounds.y, self.bounds.w, self.bounds.h)
  352.    
  353.     def draw(self):
  354.         self.game.loop(self.dt, self.t)
  355.    
  356.     def touch_began(self, touch):
  357.         self.game.screen_tapped()
  358.    
  359. run(MyScene(), PORTRAIT)
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!