SaveText.Ru

Без имени
  1. __author__ = "Shivam Shekhar"
  2.  
  3. import os
  4. import sys
  5. import pygame
  6. import random
  7. from pygame import *
  8.  
  9. pygame.mixer.pre_init(44100, -16, 2, 2048) # fix audio delay
  10. pygame.init()
  11.  
  12. scr_size = (width,height) = (600,150)
  13. FPS = 60
  14. gravity = 0.6
  15.  
  16. black = (0,0,0)
  17. white = (255,255,255)
  18. background_col = (235,235,235)
  19.  
  20. high_score = 0
  21.  
  22. screen = pygame.display.set_mode(scr_size)
  23. clock = pygame.time.Clock()
  24. pygame.display.set_caption("T-Rex Rush")
  25.  
  26. jump_sound = pygame.mixer.Sound('sprites/jump.mp3')
  27. die_sound = pygame.mixer.Sound('sprites/die.mp3')
  28. checkPoint_sound = pygame.mixer.Sound('sprites/checkPoint.mp3')
  29.  
  30. def load_image(
  31.     name,
  32.     sizex=-1,
  33.     sizey=-1,
  34.     colorkey=None,
  35.     ):
  36.  
  37.     fullname = os.path.join('sprites', name)
  38.     image = pygame.image.load(fullname)
  39.     image = image.convert()
  40.     if colorkey is not None:
  41.         if colorkey is -1:
  42.             colorkey = image.get_at((0, 0))
  43.         image.set_colorkey(colorkey, RLEACCEL)
  44.  
  45.     if sizex != -1 or sizey != -1:
  46.         image = pygame.transform.scale(image, (sizex, sizey))
  47.  
  48.     return (image, image.get_rect())
  49.  
  50. def load_sprite_sheet(
  51.         sheetname,
  52.         nx,
  53.         ny,
  54.         scalex = -1,
  55.         scaley = -1,
  56.         colorkey = None,
  57.         ):
  58.     fullname = os.path.join('sprites',sheetname)
  59.     sheet = pygame.image.load(fullname)
  60.     sheet = sheet.convert()
  61.  
  62.     sheet_rect = sheet.get_rect()
  63.  
  64.     sprites = []
  65.  
  66.     sizex = sheet_rect.width/nx
  67.     sizey = sheet_rect.height/ny
  68.  
  69.     for i in range(0,ny):
  70.         for j in range(0,nx):
  71.             rect = pygame.Rect((j*sizex,i*sizey,sizex,sizey))
  72.             image = pygame.Surface(rect.size)
  73.             image = image.convert()
  74.             image.blit(sheet,(0,0),rect)
  75.  
  76.             if colorkey is not None:
  77.                 if colorkey is -1:
  78.                     colorkey = image.get_at((0,0))
  79.                 image.set_colorkey(colorkey,RLEACCEL)
  80.  
  81.             if scalex != -1 or scaley != -1:
  82.                 image = pygame.transform.scale(image,(scalex,scaley))
  83.  
  84.             sprites.append(image)
  85.  
  86.     sprite_rect = sprites[0].get_rect()
  87.  
  88.     return sprites,sprite_rect
  89.  
  90. def disp_gameOver_msg(retbutton_image,gameover_image):
  91.     retbutton_rect = retbutton_image.get_rect()
  92.     retbutton_rect.centerx = width / 2
  93.     retbutton_rect.top = height*0.52
  94.  
  95.     gameover_rect = gameover_image.get_rect()
  96.     gameover_rect.centerx = width / 2
  97.     gameover_rect.centery = height*0.35
  98.  
  99.     screen.blit(retbutton_image, retbutton_rect)
  100.     screen.blit(gameover_image, gameover_rect)
  101.  
  102. def extractDigits(number):
  103.     if number > -1:
  104.         digits = []
  105.         i = 0
  106.         while(number/10 != 0):
  107.             digits.append(number%10)
  108.             number = int(number/10)
  109.  
  110.         digits.append(number%10)
  111.         for i in range(len(digits),5):
  112.             digits.append(0)
  113.         digits.reverse()
  114.         return digits
  115.  
  116. class Dino():
  117.     def __init__(self,sizex=-1,sizey=-1):
  118.         self.images,self.rect = load_sprite_sheet('dino.png',5,1,sizex,sizey,-1)
  119.         self.images1,self.rect1 = load_sprite_sheet('dino_ducking.png',2,1,59,sizey,-1)
  120.         self.rect.bottom = int(0.98*height)
  121.         self.rect.left = width/15
  122.         self.image = self.images[0]
  123.         self.index = 0
  124.         self.counter = 0
  125.         self.score = 0
  126.         self.isJumping = False
  127.         self.isDead = False
  128.         self.isDucking = False
  129.         self.isBlinking = False
  130.         self.movement = [0,0]
  131.         self.jumpSpeed = 11.5
  132.  
  133.         self.stand_pos_width = self.rect.width
  134.         self.duck_pos_width = self.rect1.width
  135.  
  136.     def draw(self):
  137.         screen.blit(self.image,self.rect)
  138.  
  139.     def checkbounds(self):
  140.         if self.rect.bottom > int(0.98*height):
  141.             self.rect.bottom = int(0.98*height)
  142.             self.isJumping = False
  143.  
  144.     def update(self):
  145.         if self.isJumping:
  146.             self.movement[1] = self.movement[1] + gravity
  147.  
  148.         if self.isJumping:
  149.             self.index = 0
  150.         elif self.isBlinking:
  151.             if self.index == 0:
  152.                 if self.counter % 400 == 399:
  153.                     self.index = (self.index + 1)%2
  154.             else:
  155.                 if self.counter % 20 == 19:
  156.                     self.index = (self.index + 1)%2
  157.  
  158.         elif self.isDucking:
  159.             if self.counter % 5 == 0:
  160.                 self.index = (self.index + 1)%2
  161.         else:
  162.             if self.counter % 5 == 0:
  163.                 self.index = (self.index + 1)%2 + 2
  164.  
  165.         if self.isDead:
  166.            self.index = 4
  167.  
  168.         if not self.isDucking:
  169.             self.image = self.images[self.index]
  170.             self.rect.width = self.stand_pos_width
  171.         else:
  172.             self.image = self.images1[(self.index)%2]
  173.             self.rect.width = self.duck_pos_width
  174.  
  175.         self.rect = self.rect.move(self.movement)
  176.         self.checkbounds()
  177.  
  178.         if not self.isDead and self.counter % 7 == 6 and self.isBlinking == False:
  179.             self.score += 1
  180.             if self.score % 100 == 0 and self.score != 0:
  181.                 if pygame.mixer.get_init() != None:
  182.                     checkPoint_sound.play()
  183.  
  184.         self.counter = (self.counter + 1)
  185.  
  186. class Cactus(pygame.sprite.Sprite):
  187.     def __init__(self,speed=5,sizex=-1,sizey=-1):
  188.         pygame.sprite.Sprite.__init__(self,self.containers)
  189.         self.images,self.rect = load_sprite_sheet('cacti-small.png',3,1,sizex,sizey,-1)
  190.         self.rect.bottom = int(0.98*height)
  191.         self.rect.left = width + self.rect.width
  192.         self.image = self.images[random.randrange(0,3)]
  193.         self.movement = [-1*speed,0]
  194.  
  195.     def draw(self):
  196.         screen.blit(self.image,self.rect)
  197.  
  198.     def update(self):
  199.         self.rect = self.rect.move(self.movement)
  200.  
  201.         if self.rect.right < 0:
  202.             self.kill()
  203.  
  204. class Ptera(pygame.sprite.Sprite):
  205.     def __init__(self,speed=5,sizex=-1,sizey=-1):
  206.         pygame.sprite.Sprite.__init__(self,self.containers)
  207.         self.images,self.rect = load_sprite_sheet('ptera.png',2,1,sizex,sizey,-1)
  208.         self.ptera_height = [height*0.82,height*0.75,height*0.60]
  209.         self.rect.centery = self.ptera_height[random.randrange(0,3)]
  210.         self.rect.left = width + self.rect.width
  211.         self.image = self.images[0]
  212.         self.movement = [-1*speed,0]
  213.         self.index = 0
  214.         self.counter = 0
  215.  
  216.     def draw(self):
  217.         screen.blit(self.image,self.rect)
  218.  
  219.     def update(self):
  220.         if self.counter % 10 == 0:
  221.             self.index = (self.index+1)%2
  222.         self.image = self.images[self.index]
  223.         self.rect = self.rect.move(self.movement)
  224.         self.counter = (self.counter + 1)
  225.         if self.rect.right < 0:
  226.             self.kill()
  227.  
  228.  
  229. class Ground():
  230.     def __init__(self,speed=-5):
  231.         self.image,self.rect = load_image('ground.png',-1,-1,-1)
  232.         self.image1,self.rect1 = load_image('ground.png',-1,-1,-1)
  233.         self.rect.bottom = height
  234.         self.rect1.bottom = height
  235.         self.rect1.left = self.rect.right
  236.         self.speed = speed
  237.  
  238.     def draw(self):
  239.         screen.blit(self.image,self.rect)
  240.         screen.blit(self.image1,self.rect1)
  241.  
  242.     def update(self):
  243.         self.rect.left += self.speed
  244.         self.rect1.left += self.speed
  245.  
  246.         if self.rect.right < 0:
  247.             self.rect.left = self.rect1.right
  248.  
  249.         if self.rect1.right < 0:
  250.             self.rect1.left = self.rect.right
  251.  
  252. class Cloud(pygame.sprite.Sprite):
  253.     def __init__(self,x,y):
  254.         pygame.sprite.Sprite.__init__(self,self.containers)
  255.         self.image,self.rect = load_image('cloud.png',int(90*30/42),30,-1)
  256.         self.speed = 1
  257.         self.rect.left = x
  258.         self.rect.top = y
  259.         self.movement = [-1*self.speed,0]
  260.  
  261.     def draw(self):
  262.         screen.blit(self.image,self.rect)
  263.  
  264.     def update(self):
  265.         self.rect = self.rect.move(self.movement)
  266.         if self.rect.right < 0:
  267.             self.kill()
  268.  
  269. class Scoreboard():
  270.     def __init__(self,x=-1,y=-1):
  271.         self.score = 0
  272.         self.tempimages,self.temprect = load_sprite_sheet('numbers.png',12,1,11,int(11*6/5),-1)
  273.         self.image = pygame.Surface((55,int(11*6/5)))
  274.         self.rect = self.image.get_rect()
  275.         if x == -1:
  276.             self.rect.left = width*0.89
  277.         else:
  278.             self.rect.left = x
  279.         if y == -1:
  280.             self.rect.top = height*0.1
  281.         else:
  282.             self.rect.top = y
  283.  
  284.     def draw(self):
  285.         screen.blit(self.image,self.rect)
  286.  
  287.     def update(self,score):
  288.         score_digits = extractDigits(score)
  289.         self.image.fill(background_col)
  290.         for s in score_digits:
  291.             self.image.blit(self.tempimages[s],self.temprect)
  292.             self.temprect.left += self.temprect.width
  293.         self.temprect.left = 0
  294.  
  295.  
  296. def introscreen():
  297.     temp_dino = Dino(44,47)
  298.     temp_dino.isBlinking = True
  299.     gameStart = False
  300.  
  301.     callout,callout_rect = load_image('call_out.png',196,45,-1)
  302.     callout_rect.left = width*0.05
  303.     callout_rect.top = height*0.4
  304.  
  305.     temp_ground,temp_ground_rect = load_sprite_sheet('ground.png',15,1,-1,-1,-1)
  306.     temp_ground_rect.left = width/20
  307.     temp_ground_rect.bottom = height
  308.  
  309.     logo,logo_rect = load_image('logo.png',240,40,-1)
  310.     logo_rect.centerx = width*0.6
  311.     logo_rect.centery = height*0.6
  312.     while not gameStart:
  313.         if pygame.display.get_surface() == None:
  314.             print("Couldn't load display surface")
  315.             return True
  316.         else:
  317.             for event in pygame.event.get():
  318.                 if event.type == pygame.QUIT:
  319.                     return True
  320.                 if event.type == pygame.KEYDOWN:
  321.                     if event.key == pygame.K_SPACE or event.key == pygame.K_UP:
  322.                         temp_dino.isJumping = True
  323.                         temp_dino.isBlinking = False
  324.                         temp_dino.movement[1] = -1*temp_dino.jumpSpeed
  325.  
  326.         temp_dino.update()
  327.  
  328.         if pygame.display.get_surface() != None:
  329.             screen.fill(background_col)
  330.             screen.blit(temp_ground[0],temp_ground_rect)
  331.             if temp_dino.isBlinking:
  332.                 screen.blit(logo,logo_rect)
  333.                 screen.blit(callout,callout_rect)
  334.             temp_dino.draw()
  335.  
  336.             pygame.display.update()
  337.  
  338.         clock.tick(FPS)
  339.         if temp_dino.isJumping == False and temp_dino.isBlinking == False:
  340.             gameStart = True
  341.  
  342. def gameplay():
  343.     global high_score
  344.     gamespeed = 4
  345.     startMenu = False
  346.     gameOver = False
  347.     gameQuit = False
  348.     playerDino = Dino(44,47)
  349.     new_ground = Ground(-1*gamespeed)
  350.     scb = Scoreboard()
  351.     highsc = Scoreboard(width*0.78)
  352.     counter = 0
  353.  
  354.     cacti = pygame.sprite.Group()
  355.     pteras = pygame.sprite.Group()
  356.     clouds = pygame.sprite.Group()
  357.     last_obstacle = pygame.sprite.Group()
  358.  
  359.     Cactus.containers = cacti
  360.     Ptera.containers = pteras
  361.     Cloud.containers = clouds
  362.  
  363.     retbutton_image,retbutton_rect = load_image('replay_button.png',35,31,-1)
  364.     gameover_image,gameover_rect = load_image('game_over.png',190,11,-1)
  365.  
  366.     temp_images,temp_rect = load_sprite_sheet('numbers.png',12,1,11,int(11*6/5),-1)
  367.     HI_image = pygame.Surface((22,int(11*6/5)))
  368.     HI_rect = HI_image.get_rect()
  369.     HI_image.fill(background_col)
  370.     HI_image.blit(temp_images[10],temp_rect)
  371.     temp_rect.left += temp_rect.width
  372.     HI_image.blit(temp_images[11],temp_rect)
  373.     HI_rect.top = height*0.1
  374.     HI_rect.left = width*0.73
  375.  
  376.     while not gameQuit:
  377.         while startMenu:
  378.             pass
  379.         while not gameOver:
  380.             if pygame.display.get_surface() == None:
  381.                 print("Couldn't load display surface")
  382.                 gameQuit = True
  383.                 gameOver = True
  384.             else:
  385.                 for event in pygame.event.get():
  386.                     if event.type == pygame.QUIT:
  387.                         gameQuit = True
  388.                         gameOver = True
  389.  
  390.                     if event.type == pygame.KEYDOWN:
  391.                         if event.key == pygame.K_SPACE:
  392.                             if playerDino.rect.bottom == int(0.98*height):
  393.                                 playerDino.isJumping = True
  394.                                 if pygame.mixer.get_init() != None:
  395.                                     jump_sound.play()
  396.                                 playerDino.movement[1] = -1*playerDino.jumpSpeed
  397.  
  398.                         if event.key == pygame.K_DOWN:
  399.                             if not (playerDino.isJumping and playerDino.isDead):
  400.                                 playerDino.isDucking = True
  401.  
  402.                     if event.type == pygame.KEYUP:
  403.                         if event.key == pygame.K_DOWN:
  404.                             playerDino.isDucking = False
  405.             for c in cacti:
  406.                 c.movement[0] = -1*gamespeed
  407.                 if pygame.sprite.collide_mask(playerDino,c):
  408.                     playerDino.isDead = True
  409.                     if pygame.mixer.get_init() != None:
  410.                         die_sound.play()
  411.  
  412.             for p in pteras:
  413.                 p.movement[0] = -1*gamespeed
  414.                 if pygame.sprite.collide_mask(playerDino,p):
  415.                     playerDino.isDead = True
  416.                     if pygame.mixer.get_init() != None:
  417.                         die_sound.play()
  418.  
  419.             if len(cacti) < 2:
  420.                 if len(cacti) == 0:
  421.                     last_obstacle.empty()
  422.                     last_obstacle.add(Cactus(gamespeed,40,40))
  423.                 else:
  424.                     for l in last_obstacle:
  425.                         if l.rect.right < width*0.7 and random.randrange(0,50) == 10:
  426.                             last_obstacle.empty()
  427.                             last_obstacle.add(Cactus(gamespeed, 40, 40))
  428.  
  429.             if len(pteras) == 0 and random.randrange(0,200) == 10 and counter > 500:
  430.                 for l in last_obstacle:
  431.                     if l.rect.right < width*0.8:
  432.                         last_obstacle.empty()
  433.                         last_obstacle.add(Ptera(gamespeed, 46, 40))
  434.  
  435.             if len(clouds) < 5 and random.randrange(0,300) == 10:
  436.                 Cloud(width,random.randrange(height/5,height/2))
  437.  
  438.             playerDino.update()
  439.             cacti.update()
  440.             pteras.update()
  441.             clouds.update()
  442.             new_ground.update()
  443.             scb.update(playerDino.score)
  444.             highsc.update(high_score)
  445.  
  446.             if pygame.display.get_surface() != None:
  447.                 screen.fill(background_col)
  448.                 new_ground.draw()
  449.                 clouds.draw(screen)
  450.                 scb.draw()
  451.                 if high_score != 0:
  452.                     highsc.draw()
  453.                     screen.blit(HI_image,HI_rect)
  454.                 cacti.draw(screen)
  455.                 pteras.draw(screen)
  456.                 playerDino.draw()
  457.  
  458.                 pygame.display.update()
  459.             clock.tick(FPS)
  460.  
  461.             if playerDino.isDead:
  462.                 gameOver = True
  463.                 if playerDino.score > high_score:
  464.                     high_score = playerDino.score
  465.  
  466.             if counter%700 == 699:
  467.                 new_ground.speed -= 1
  468.                 gamespeed += 1
  469.  
  470.             counter = (counter + 1)
  471.  
  472.         if gameQuit:
  473.             break
  474.  
  475.         while gameOver:
  476.             if pygame.display.get_surface() == None:
  477.                 print("Couldn't load display surface")
  478.                 gameQuit = True
  479.                 gameOver = False
  480.             else:
  481.                 for event in pygame.event.get():
  482.                     if event.type == pygame.QUIT:
  483.                         gameQuit = True
  484.                         gameOver = False
  485.                     if event.type == pygame.KEYDOWN:
  486.                         if event.key == pygame.K_ESCAPE:
  487.                             gameQuit = True
  488.                             gameOver = False
  489.  
  490.                         if event.key == pygame.K_RETURN or event.key == pygame.K_SPACE:
  491.                             gameOver = False
  492.                             gameplay()
  493.             highsc.update(high_score)
  494.             if pygame.display.get_surface() != None:
  495.                 disp_gameOver_msg(retbutton_image,gameover_image)
  496.                 if high_score != 0:
  497.                     highsc.draw()
  498.                     screen.blit(HI_image,HI_rect)
  499.                 pygame.display.update()
  500.             clock.tick(FPS)
  501.  
  502.     pygame.quit()
  503.     quit()
  504.  
  505. def main():
  506.     isGameQuit = introscreen()
  507.     if not isGameQuit:
  508.         gameplay()
  509.  
  510. main()

Share with your friends:

Print