API tools faq
paste
Advertisement
Guest User

Game_headless.py

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