API tools faq
paste
Advertisement
Ridz112

Untitled

Ridz112
Oct 30th, 2021
75
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 25.57 KB | None | 0 0
raw download clone embed print report
  1. from pygame import *
  2. import random
  3.  
  4. spawnpoint = 0
  5. x = 1
  6. while x != 10:
  7.     spawnpoint += random.randint(1, 10)
  8.     x = x + 1
  9.  
  10. init()
  11. width = 1500  # width of window
  12. height = 800  # height of window
  13. window = display.set_mode((width, height))  # draws window
  14. screen = display.get_surface()  # draws ontop of window
  15. exitProg = False  # allows to exit while loop
  16. overallTime = time.Clock()  # starts a clock
  17.  
  18.  
  19. ######################################################################
  20. # player interaction
  21. class Character():
  22.     def __init__(self, m, n, movement, spawnpoint):  # initialises the objects
  23.         self.Posx = m  # sets the image to the center of the map
  24.         self.Posy = n  # sets the image to the center of the map
  25.         self.dx = 0  # sets horizontal acceleration to 0
  26.         self.dy = 0  # sets vertical acceleration to 0
  27.         self.Movespeed = movement  # sets how fast the player moves(it can change)
  28.         self.image = image.load('Isaac.xcf')  # loads the sprite for the player
  29.         self.sword = image.load('swordSwish2.png')  # loads the sword for the sprite
  30.         self.roomCounter = 0  # sets the room counter
  31.         self.ATK = 8  # sets the attack of the player
  32.         self.HP = 25  # sets the hp of the player
  33.         self.maxhp = 25  # the hp and masx hp will be equal to beging with and only the curhp should change when damage is taken
  34.         self.attackspeed = 1  # sets attack speed of the player
  35.         self.spawnpoint = spawnpoint  # assigns where the player has begun on the map
  36.  
  37.     def collisionDoor(self, door, locked):  # detects door collisions for the player
  38.         rect = self.image.get_rect()  # gets the dimensions of the sprite
  39.         rect.x = self.Posx  # sets coords for a rectangle == to the sprite
  40.         rect.y = self.Posy  # sets coords for a rectangle == to the sprite
  41.         spawnRoom = None  # changes it so that the value that shows the room the player begun in is changed
  42.         if rect.colliderect(door) == True and locked == False:  # checks for collision between player and door
  43.             clock.resettime()
  44.             if self.Posx > 1342:  # collisionDoor also changes the position of the player and then changes where the player is on the map
  45.                 self.Posx = 95
  46.                 self.spawnpoint += 1
  47.                 spawnRoom = self.spawnpoint
  48.             if self.Posx < 94:
  49.                 self.Posx = 1341
  50.                 self.spawnpoint -= 1
  51.                 spawnRoom = self.spawnpoint
  52.             if self.Posy > 642:
  53.                 self.Posy = 103
  54.                 self.spawnpoint += 10
  55.                 spawnRoom = self.spawnpoint
  56.             if self.Posy < 102:
  57.                 self.Posy = 643
  58.                 self.spawnpoint -= 10
  59.                 spawnRoom = self.spawnpoint
  60.             character.update()
  61.             if spawnRoom != None and not (
  62.                     spawnRoom in visited):  # if the player is in a room they havent visited before, append it to the visited list
  63.                 visited.append(spawnRoom)
  64.                 self.roomCounter += 1  # increase the room counter
  65.             else:
  66.                 return False
  67.             return True  # the code also checks for a change in the room and returns true, I use it for this purpose a bit
  68.         return False
  69.  
  70.     def collisiondoorother(self, door, locked, dead):
  71.         rect = self.image.get_rect()  # gets the dimensions of the sprite
  72.         rect.x = self.Posx  # sets coords for a rectangle == to the sprite
  73.         rect.y = self.Posy  # sets coords for a rectangle == to the sprite
  74.         if rect.colliderect(
  75.                 door) == True and locked == False and dead == True:  # checks for collision between player and door
  76.             return True
  77.         return False
  78.  
  79.     def getPosition(self):  # allows other classes to get the poisition of the player
  80.         return self.Posx, self.Posy
  81.  
  82.     def moveleft(self):  # sets the change in speed
  83.         self.dx = -self.Movespeed
  84.         return self.Posx
  85.  
  86.     def moveright(self):  # sets the change in speed
  87.         self.dx = self.Movespeed
  88.         return self.Posx
  89.  
  90.     def movedown(self):  # sets the change in speed
  91.         self.dy = -self.Movespeed
  92.         return self.Posy
  93.  
  94.     def moveup(self):  # sets the change in speed
  95.         self.dy = self.Movespeed
  96.         return self.Posy
  97.  
  98.     def stopHorizontal(self):  # stops character moving
  99.         self.dx = 0
  100.  
  101.     def stopVertical(self):  # stops character moving
  102.         self.dy = 0
  103.  
  104.     def bordercheckx(self):  # stops character moving past screen
  105.         if self.Posx > 1364:
  106.             self.Posx = 1364
  107.         if self.Posx < 89:
  108.             self.Posx = 89
  109.         return self.Posx
  110.  
  111.     def borderchecky(self):  # stops char moving past screen
  112.         if self.Posy > 652:
  113.             self.Posy = 652
  114.         if self.Posy < 90:
  115.             self.Posy = 90
  116.         return self.Posy
  117.  
  118.     def update(self):  # changes the coords for the sprite
  119.         self.Posx = self.Posx + self.dx
  120.         self.Posy = self.Posy + self.dy
  121.  
  122.     def show(self):  # updates the players position on the map
  123.         screen.blit(self.image, (self.Posx, self.Posy))
  124.  
  125.     def returnRect(self):  # gets the rect for the player to compare for collision
  126.         rect = Rect(self.Posx, self.Posy, self.image.get_width(), self.image.get_height())
  127.         return rect
  128.  
  129.     def returnSwordrect(
  130.             self):  # sword rect based on the players position and returns it to check for collision against enemies
  131.         rect = Rect(self.Posx - 20, self.Posy - 20, self.sword.get_width(), self.sword.get_height())
  132.         return rect
  133.  
  134.     def GetRoomCount(self):  # returns room counter
  135.         return self.roomCounter
  136.  
  137.     def attack(self, target):
  138.         target.reduceHP(self.ATK)  # damage done to the monster being attacked
  139.  
  140.     def ShowAttack(self):  # shows the sword when called
  141.         screen.blit(self.sword, (self.Posx - 20, self.Posy - 14))
  142.  
  143.     def reduceHP(self, amount):  # HP stat is encaptulated so it cant be
  144.         self.HP -= amount
  145.  
  146.     def returncurHP(self):  # returns the current health of the player
  147.         return self.HP
  148.  
  149.     def returnmaxHP(self):  # returns the max health of the player
  150.         return self.maxhp
  151.  
  152.     def isDead(self):  # This checks how high the monsters health
  153.         if self.HP <= -1:
  154.             return True  # is and then returns true or false if its
  155.         else:
  156.             return False
  157.  
  158.     def levelUP(self):  # this levels up the player and increases the players stats and heals them fully
  159.         self.ATK = round(self.ATK * 1.5)
  160.         self.maxhp = round(self.maxhp * 1.2)
  161.         self.HP = self.maxhp
  162.  
  163.     def changemodel(self):
  164.         health = (self.HP / self.maxhp)
  165.         if health <= 0.1:
  166.             self.image = image.load('Isaacdam5.png')
  167.         elif health <= 0.2 and health > 0.1:
  168.             self.image = image.load('Isaacdam4.png')
  169.         elif health <= 0.4 and health > 0.2:
  170.             self.image = image.load('Isaacdam3.png')
  171.         elif health <= 0.6 and health > 0.4:
  172.             self.image = image.load('Isaacdam2.png')
  173.         elif health <= 0.8 and health > 0.6:
  174.             self.image = image.load('Isaacdam1.png')
  175.         else:
  176.             self.image = image.load('Isaac.png')
  177.  
  178.     def getatkspd(self):
  179.         return self.attackspeed
  180.  
  181.     def resetroomcount(self):
  182.         self.roomCounter = 0
  183.     ######################################################################
  184.  
  185.  
  186. # Door interactions with player
  187. class doors(Rect):  # draws the doors in their positions
  188.     def draw(self, screen):
  189.         draw.rect(screen, (225, 225, 225), self)
  190.  
  191.     def lock(self, screen):  # changes colour of the doors if they are locked
  192.         draw.rect(screen, (255, 215, 0), self)
  193.  
  194.  
  195. ######################################################################
  196. # levels up the player
  197. class levelUp():
  198.  
  199.     def __init__(self, currentXP, NeededtoLVL):  # initialises the level up system
  200.         self.currentXP = currentXP
  201.         self.neededtoLVL = NeededtoLVL
  202.         self.level = 1
  203.  
  204.     def xpgain(self, xpgained):  # levels up the player
  205.         self.currentXP += xpgained
  206.         if self.currentXP >= self.neededtoLVL:
  207.             self.currentXP -= self.neededtoLVL
  208.             self.neededtoLVL *= 1.7
  209.             self.level += 1
  210.             character.levelUP()
  211.  
  212.     def drawXPbar(self):  # Draws the xp bar on the screen and changes it
  213.         width = 1000 * (self.currentXP / self.neededtoLVL)
  214.         bar1 = Rect(250, 760, 1000, 10)
  215.         bar2 = Rect(250, 760, width, 10)
  216.         draw.rect(screen, (166, 16, 30), bar1)
  217.         draw.rect(screen, (0, 229, 238), bar2)
  218.  
  219.     def getLVL(self):  # returns the level of the player to be drawn on the screen
  220.         return self.level
  221.  
  222.  
  223. ######################################################################
  224. # Creates and controls the enemies
  225. class Enemy():
  226.     def __init__(self):  # initialises the enemies
  227.         self.Enx = 0  # sets the position of every enemy to begin with in the top right corner
  228.         self.Eny = 0  # sets all the stats for the enemy to be 0 as the stats need to be set with the enemy type
  229.         self.dx = 0  # they all need to be set to 0 except for health so they cant do anything
  230.         self.dy = 0  # the health is so high so that it doesnt accidentally trigger the death function for the enemies
  231.         self.speed = 0
  232.         self.HP = 99999999999
  233.         self.ATK = 0
  234.         self.image = image.load('blank.png')
  235.  
  236.         self.attackspeed = 0
  237.         self.xpGain = 7
  238.         self.levelmult = 1
  239.         self.levelmultboss = 1
  240.         self.xpmodifier = 1
  241.         self.height = 0
  242.         self.width = 0
  243.  
  244.     def moveToPlayer(self, x, y, time):  # checks where the player is then moves to the position
  245.         if time > 1:
  246.             if x - self.width < self.Enx:
  247.                 self.dx = -self.speed
  248.             if x - self.width > self.Enx:
  249.                 self.dx = self.speed
  250.             if y - self.height > self.Eny:
  251.                 self.dy = self.speed
  252.             if y - self.height < self.Eny:
  253.                 self.dy = -self.speed
  254.  
  255.     def playerCollidesDoor(self,
  256.                            enter):  # checks if the player has entered a door, if it has then it resets the enemies
  257.         if enter == True:
  258.             self.Enx = random.randint(300, 1200)
  259.             self.Eny = random.randint(300, 500)
  260.             self.dx = 0
  261.             self.dy = 0
  262.  
  263.     def collisionSword(self, sword):  # checks if the enemy collides with the swords hit box
  264.         enemy = Rect(self.Enx, self.Eny, self.image.get_width(), self.image.get_height())
  265.         if enemy.colliderect(sword) == True:
  266.             return True
  267.         return False
  268.  
  269.     def collisionPlayer(self, player):  # checks if the player touches the enemy
  270.         rect = Rect(self.Enx, self.Eny, self.image.get_width(), self.image.get_height())
  271.         if rect.colliderect(player) == True:
  272.             EnATKSpd.resettime()
  273.             return True
  274.         return False
  275.  
  276.     def Archer(self):  # sets the Archer class for enemies
  277.         self.HP = round(8 * self.levelmult)
  278.         self.ATK = round(3 * self.levelmult)
  279.         self.speed = 1.5
  280.         self.attackspeed = 1
  281.         self.image = image.load('Archer.png')
  282.         self.width = -5
  283.  
  284.     def Orc(self):  # sets the Orc class for enemies
  285.         self.HP = round(22 * self.levelmult)
  286.         self.ATK = round(3 * self.levelmult)
  287.         self.speed = 1.3
  288.         self.attackspeed = 1
  289.         self.image = image.load('Orc2.png')
  290.         self.height = 25
  291.         self.width = 5
  292.  
  293.     def Soldier(self):  # sets the Soldier class for enemies
  294.         self.HP = round(14 * self.levelmult)
  295.         self.ATK = round(2 * self.levelmult)
  296.         self.speed = 1.7
  297.         self.attackspeed = 1
  298.         self.image = image.load('soldier.png')
  299.         self.width = -5
  300.  
  301.     def blank(self):
  302.         self.HP = 9999999
  303.         self.ATK = 0
  304.         self.speed = 0
  305.         self.image = image.load('blank.png')
  306.         self.Enx = 1
  307.         self.Eny = 1
  308.  
  309.     def update(self):  # changes the speed of the enemy
  310.         self.Enx = self.Enx + self.dx
  311.         self.Eny = self.Eny + self.dy
  312.  
  313.     def show(self):  # updates the enemy on the map
  314.         screen.blit(self.image, (self.Enx, self.Eny))
  315.  
  316.     def attack(self, target):
  317.         target.reduceHP(self.ATK)  # damage done to the monster being attacker
  318.  
  319.     def reduceHP(self, amount):  # HP stat is encapsulated so it cant be
  320.         self.HP -= amount
  321.  
  322.     def isDead(self):  # This checks how high the monsters health
  323.         if self.HP <= 0:  # is and then returns true or false if its
  324.             self.image = image.load('blank.png')
  325.             self.ATK = 0
  326.             self.Enx = 1
  327.             self.Eny = 1
  328.             self.HP = 9999999
  329.             self.speed = 0
  330.             xpgain = self.xpGain * self.xpmodifier
  331.             CharLVL.xpgain(xpgain)
  332.  
  333.             return True
  334.         else:
  335.             return False
  336.  
  337.     def returnHP(self):
  338.         return self.HP
  339.  
  340.     def Boss(self):
  341.         self.HP = round(50 * self.levelmultboss)
  342.         self.ATK = round(5 * self.levelmultboss)
  343.         self.speed = 1
  344.         self.attackspeed = 4
  345.         self.image = image.load('boss.png')
  346.         self.Enx = 750
  347.         self.Eny = 350
  348.         self.height = 40
  349.         self.width = 30
  350.  
  351.     def levelup(self):
  352.         self.levelmultboss = self.levelmultboss * 1.2
  353.         self.levelmult = self.levelmult * 1.25
  354.         self.xpmodifier = self.xpmodifier * 1.2
  355.  
  356.  
  357. ######################################################################
  358. # Sets the time for the game
  359. class gameTime():
  360.     duration = 0
  361.  
  362.     def __init__(self):  # just initialises the objects
  363.         pass
  364.  
  365.     def increase(self):
  366.         self.duration += 0.016  # how long a frame is in secs
  367.  
  368.     def gettime(self):
  369.         return self.duration  # returns time
  370.  
  371.     def printtime(self):
  372.         print(self.duration)  # shows the time
  373.  
  374.     def resettime(self):
  375.         self.duration = 0  # resets the clock
  376.  
  377.  
  378. ######################################################################
  379. # draws User interface stuff and changes it
  380. class UI():
  381.     def __init__(self, HP):  # inititalises the objects
  382.         pass
  383.  
  384.     def drawHPbar(self, curHP,
  385.                   maxHP):  # draws the hp bar in relation to how much health the player has left compared to the max health of the player
  386.         width = 400 * (int(curHP) / int(maxHP))
  387.         bar1 = Rect(40, 40, 400, 10)
  388.         bar2 = Rect(40, 40, width, 10)
  389.         draw.rect(screen, (166, 16, 30), bar1)  # draws bar that shows lost health
  390.         draw.rect(screen, (0, 255, 0), bar2)  # draws bar that shows how much health the player has
  391.  
  392.     def showhealth(self, curHP, maxHP):  # writes out with numbers how much health the player has as a fraction
  393.         text.showtext(str(character.returncurHP()), screen, (200, 0, 200), 465, 34)
  394.         text.showtext("___", screen, (200, 0, 200), 465, 34)
  395.         text.showtext(str(maxHP), screen, (200, 0, 200), 465, 61)
  396.  
  397.     def dead(self, curHP):  # if the player dies, replace the screen with a balck screen and write game over
  398.         if curHP < 1:
  399.             text.showtext("Game Over", screen, (255, 255, 255), 700, 400)
  400.             return True
  401.         return False
  402.  
  403.     def drawattackbar(self,
  404.                       attackspeed):  # draws the attack speed bar in relation to how fast the player can attack compared to how long it has been since the players last successful hit
  405.         width = 100 * attackspeed
  406.         if width > 100:
  407.             width = 100
  408.         bar1 = Rect(1200, 40, 100, 10)
  409.         bar2 = Rect(1200, 40, width, 10)
  410.  
  411.         draw.rect(screen, (166, 16, 30), bar1)  # draws how much time left to wait for next attack
  412.         draw.rect(screen, (0, 255, 0), bar2)  # draws how much tiem waited for next attack
  413.  
  414.  
  415. ######################################################################
  416. class Text():
  417.     def __init__(self):  # initialises text
  418.         pass
  419.  
  420.     def showtext(self, text, screen, colour, x, y):  # calls the message display function
  421.         self.message_display(text, screen, colour, x, y)
  422.  
  423.     def message_display(self, text, screen, colour, x, y):  # blits the text onto the screen
  424.         largetext = font.Font("freesansbold.ttf", 25)  # sets size and font of text
  425.         TextSurf, TextRect = self.text_objects(text, largetext, colour)  # calls text objects function
  426.         TextRect.center = (x, y)  # gets the center of the rectangle with position x,y
  427.         screen.blit(TextSurf, TextRect)  # blits the text
  428.  
  429.     def text_objects(self, text, font, colour):  # assigns the colour and renders the text
  430.         textSurface = font.render(text, True, (colour))
  431.         return textSurface, textSurface.get_rect()  # returns the rendered text and rectangle of text
  432.  
  433.  
  434. ######################################################################
  435. ######################################################################
  436.  
  437. gameMap = [[[0], [1], [2], [3], [4], [5], [6], [7], [8], [9]]
  438.     , [[10], [11], [12], [13], [14], [15], [16], [17], [18], [19]]
  439.     , [[20], [21], [22], [23], [24], [25], [26], [27], [28], [29]]
  440.     , [[30], [31], [32], [33], [34], [35], [36], [37], [38], [39]]
  441.     , [[40], [41], [42], [43], [44], [45], [46], [47], [48], [49]]
  442.     , [[50], [51], [52], [53], [54], [55], [56], [57], [58], [59]]
  443.     , [[60], [61], [62], [63], [64], [65], [66], [67], [68], [69]]
  444.     , [[70], [71], [72], [73], [74], [75], [76], [77], [78], [79]]
  445.     , [[80], [81], [82], [83], [84], [85], [86], [87], [88], [89]]
  446.     , [[90], [91], [92], [93], [94], [95], [96], [97], [98], [99]]]
  447.  
  448. firstroom = 1
  449. visited = []  # creates an empty array for visited rooms
  450. visited.append(spawnpoint)  # appends the place where the player starts to the visited list
  451.  
  452. textpos = 400  # this is just setting variables used later
  453. text = Text()  # creates an object for the text class
  454.  
  455. justonce = True
  456. showdamage = 0
  457. enemycount = 0
  458. number = 1
  459. nextlevel = False
  460. boss = False
  461. bossisdead = False
  462. locked = False  # this is just setting variables used later
  463. collided = False  # this is just setting variables used later
  464. plyAtkSpd = gameTime()  # creates an object for the player attack speed
  465. EnATKSpd = gameTime()  # creates an object for the enemy attack speed
  466. clock = gameTime()  # creates an object for the clock
  467. m, n = 720, 370  # this is just setting variables used later
  468. x, y = 0, 0  # this is just setting variables used later
  469. length = random.randint(6, 10)
  470.  
  471. enemy1 = Enemy()  # sets the enemies
  472. enemy2 = Enemy()
  473. enemy3 = Enemy()
  474. enemy4 = Enemy()
  475. enemy5 = Enemy()
  476. enemy6 = Enemy()
  477. enemies = [enemy1, enemy2, enemy3, enemy4, enemy5, enemy6]  # creates list of enemies
  478.  
  479. character = Character(m, n, 3.2, spawnpoint)  # sets character class
  480. CharLVL = levelUp(0, 100)  # sets char level class
  481. HPbar = UI(character.returncurHP())
  482.  
  483. doorwest = doors(85, 350, 10, 100)  # sets a door
  484. dooreast = doors(1405, 350, 10, 100)  # sets a door
  485. doornorth = doors(700, 85, 100, 10)  # sets a door
  486. doorsouth = doors(700, 705, 100, 10)  # sets a door
  487.  
  488. roomModel = (90, 90, 1320, 620)  # sets background size
  489. key.set_repeat(1, 30)  # sets keys to repeat
  490.  
  491. nextleveldoor = doors(700, 350, 100, 100)
  492. doors = [doorwest, dooreast, doornorth, doorsouth]  # creates list of doors
  493.  
  494. fill = (40, 0, 0)
  495. once = 1
  496.  
  497. while exitProg == False:  # loops while the program is running
  498.     for e in event.get():
  499.         if e.type == constants.QUIT:  # if quit buttom pressed, end loop
  500.             exitProg = True
  501.  
  502.         if e.type == KEYDOWN:  # if key is pressed, move the character in the direction
  503.             if (e.key == constants.K_a):
  504.                 character.moveleft()
  505.             if (e.key == constants.K_d):
  506.                 character.moveright()
  507.             if (e.key == constants.K_w):
  508.                 character.movedown()
  509.             if (e.key == constants.K_s):
  510.                 character.moveup()
  511.             if (e.key == constants.K_SPACE):
  512.                 character.ShowAttack()
  513.  
  514.         if e.type == KEYUP:  # stops the character moving after the key is let go
  515.             if (e.key == constants.K_a):
  516.                 character.stopHorizontal()
  517.             if (e.key == constants.K_d):
  518.                 character.stopHorizontal()
  519.             if (e.key == constants.K_w):
  520.                 character.stopVertical()
  521.             if (e.key == constants.K_s):
  522.                 character.stopVertical()
  523.             if (e.key == constants.K_SPACE):
  524.                 character.ShowAttack()
  525.     screen.fill(fill)  # fills the screen
  526.     draw.rect(screen, (20, 173, 70), roomModel)  # draws the green background
  527.  
  528.     for door in doors:
  529.         door.draw(screen)
  530.         if character.collisionDoor(door, locked) == True:
  531.             collided = True
  532.  
  533.         if nextlevel == True:
  534.             nextleveldoor.draw(screen)
  535.             if character.collisionDoor(nextleveldoor, locked) == True:
  536.                 collided = True
  537.  
  538.     EnATKSpd.increase()
  539.     plyAtkSpd.increase()
  540.     clock.increase()  # increases clock time
  541.     p, q = character.getPosition()  # gets position of the player
  542.     time = clock.gettime()  # gets current time
  543.  
  544.     for enemy in enemies:  # for each enemy
  545.         if enemycount != 0:  # if there are enemies on the screen
  546.             for door in doors:
  547.                 door.lock(screen)  # lock the doors
  548.             locked = True  # set the lock to be true
  549.         else:
  550.             locked = False  # if there are no enemies, then unlock
  551.  
  552.         if boss == True and once == 1:
  553.             enemy.Boss()
  554.             once += 1
  555.             enemycount += 1
  556.  
  557.         if boss == True and enemycount == 0:
  558.             nextlevel = True
  559.             once = 1
  560.             boss = False
  561.             bossisdead = True
  562.  
  563.         if enemy.attackspeed < EnATKSpd.gettime():  # if the enemy can attack as its time before next attack is above time since last attack
  564.             if enemy.collisionPlayer(character.returnRect()) == True:  # if its touching the player
  565.                 enemy.attack(character)  # attack the player
  566.  
  567.         if e.type == KEYDOWN:  # if the plasyer presses space
  568.             if (e.key == constants.K_SPACE):
  569.                 character.ShowAttack()  # show the sword
  570.                 if enemy.collisionSword(
  571.                         character.returnSwordrect()) == True and plyAtkSpd.gettime() >= character.getatkspd():  # if the sword collides with the enemy
  572.                     character.attack(enemy)  # then attack
  573.                     plyAtkSpd.resettime()  # reset the players time to next attack
  574.                     number = 10
  575.  
  576.         if enemy.returnHP() < 1:
  577.             enemycount -= 1
  578.             enemy.isDead()
  579.  
  580.         if character.GetRoomCount() >= length:
  581.             collided = False
  582.             boss = True
  583.             character.resetroomcount()
  584.  
  585.             length = length + random.randint(-1, 6)
  586.  
  587.         if collided == True:  # if the doors are touched and entered
  588.             spawnRate = random.randint(1, 100)
  589.             if spawnRate <= 20:
  590.                 enemy.Archer()
  591.                 enemycount += 1
  592.             if spawnRate >= 21 and spawnRate <= 40:
  593.                 enemy.Orc()
  594.                 enemycount += 1
  595.             if spawnRate >= 41 and spawnRate <= 60:
  596.                 enemy.Soldier()
  597.                 enemycount += 1
  598.             if spawnRate >= 61:
  599.                 enemy.blank()  # select the enemies
  600.  
  601.         enemy.playerCollidesDoor(collided)  # randomly spawn in enemies on the map
  602.         enemy.moveToPlayer(p, q, time)  # moves the enemy to the player
  603.         enemy.update()
  604.  
  605.         if showdamage % number <= 5:
  606.             enemy.show()  # update enemies position and blits it
  607.  
  608.     character.update()  # updates players position
  609.  
  610.     CharLVL.drawXPbar()  # draws the xp bar for the player
  611.     text.showtext("level " + str(CharLVL.getLVL()), screen, (200, 0, 200), 200,
  612.                   765)  # writes the level of the player next to the xp bar
  613.  
  614.     character.bordercheckx()  # checks if player is out of bounds
  615.     character.borderchecky()  # checks if player is out of bounds
  616.     character.changemodel()
  617.     text.showtext("attack speed", screen, (200, 0, 200), 1110, 45)  # writes attack speed onto the screen
  618.  
  619.     a = character.returncurHP()  # sets a variable for the current hp of the player
  620.     b = character.returnmaxHP()  # sets a variable for the max hp of player
  621.     HPbar.drawHPbar(a, b)  # draws the hp bar in relation to the cur and max hp
  622.     HPbar.showhealth(a, b)  # writes the total health and current health as a fraction
  623.     HPbar.drawattackbar(plyAtkSpd.gettime())  # draws the attack speed bar for the player
  624.  
  625.     if HPbar.dead(character.returncurHP()) == True:  # if the player dies
  626.         screen.fill((0, 0, 0))  # make the screen go black
  627.         HPbar.dead(character.returncurHP())  # the player dies and the screen says game over
  628.         firstroom = 10
  629.  
  630.     print(character.GetRoomCount())
  631.  
  632.     if character.collisiondoorother(nextleveldoor, locked, bossisdead) == True:
  633.         enemy.levelup()
  634.         red = random.randint(0, 80)
  635.         green = random.randint(0, 80)
  636.         blue = random.randint(0, 80)
  637.         fill = (red, green, blue)
  638.         bossisdead = False
  639.         nextlevel = False
  640.         firstroom += 1
  641.  
  642.     character.show()  # shows players position on screen
  643.  
  644.     if e.type == KEYDOWN:
  645.         if (e.key == constants.K_SPACE):  # if the player presses space
  646.             character.ShowAttack()  # show the attack
  647.  
  648.     if plyAtkSpd.gettime() >= 0.8:
  649.         number = 1
  650.     if length < 6:
  651.         length == 6
  652.     showdamage = showdamage + 1
  653.     collided = False  # resets collided
  654.     overallTime.tick(60)  # sets fps
  655.     display.flip()  # shows the entire screen
  656.  
  657.  
  658.  
  659.  
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!