-
-
Save Knowledge-soda/d9ddfdc64fd0f965f841 to your computer and use it in GitHub Desktop.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| import pygame | |
| from pygame import * | |
| import random | |
| import tiledtmxloader | |
| class pusher: | |
| def __init__(self, x1, y1, image, obj, do1=None, do2=None, time=0, pos_do=None, | |
| anti_pos_do=None, infinity=0, proces=2): | |
| self.x1, self.y1 = x1, y1 | |
| self.image = image | |
| self.x2, self.y2 = self.image.get_size() | |
| self.obj = obj | |
| self.do1 = do1 | |
| self.do2 = do2 | |
| self.time = time | |
| self.proces = proces | |
| self.pos_do = pos_do | |
| self.anti_pos_do = anti_pos_do | |
| self.infinity = infinity | |
| def be(self): | |
| self.x, self.y = pygame.mouse.get_pos() | |
| if self.proces == 2: | |
| if self.x2 + self.x1 > self.x > self.x1: | |
| if self.y2 + self.y1 > self.y > self.y1: | |
| self.obj.change(self.pos_do) | |
| if self.obj.mouse is True: | |
| self.t = pygame.time.get_ticks() | |
| if self.infinity < 2: | |
| self.proces = 1 | |
| self.obj.change(self.do1) | |
| else: | |
| self.obj.change(self.anti_pos_do) | |
| else: | |
| self.obj.change(self.anti_pos_do) | |
| if self.proces == 1: | |
| if pygame.time.get_ticks() - self.t > self.time: | |
| self.obj.change(self.do2) | |
| if self.infinity < 1: | |
| self.proces = 0 | |
| self.obj.change(self.anti_pos_do) | |
| else: | |
| self.recall() | |
| if self.proces > 0: | |
| self.obj.screen.blit(self.image, (self.x1, self.y1)) | |
| def update(self, x1, y1, image, obj, do1=None, do2=None, time=0, pos_do=None, anti_pos_do=None, | |
| infinity=0): | |
| self.x1, self.y1, = x1, y1 | |
| self.image = image | |
| self.x2, self.y2 = self.image.get_size() | |
| self.obj = obj | |
| self.do1 = do1 | |
| self.do2 = do2 | |
| self.time = time | |
| self.mouse = False | |
| self.pos_do = pos_do | |
| self.anti_pos_do = anti_pos_do | |
| self.infinity = infinity | |
| def recall(self): | |
| self.proces = 2 | |
| def collide(obj1, obj2): | |
| ret = [] | |
| if obj2.y + obj2.y1 > obj1.y + obj1.y1 > obj2.y and obj1.x + obj1.x1 > obj2.x and obj1.x\ | |
| < obj2.x + obj2.x1: | |
| ret.append('upcollide') | |
| if obj2.y + obj2.y1 > obj1.y > obj2.y and obj1.x + obj1.x1 > obj2.x and obj1.x < obj2.x + \ | |
| obj2.x1: | |
| ret.append('downcollide') | |
| if 'upcollide' in ret: | |
| if 'downcollide' in ret: | |
| if obj1.x < obj2.x: | |
| return 'leftcollide' | |
| elif obj1.x + obj1.x1 > obj2.x + obj2.x1: | |
| return 'rightcollide' | |
| else: | |
| return 'upcollide' | |
| elif 'downcollide' in ret: | |
| return 'downcollide' | |
| class Laser: | |
| def __init__(self, x, y, direction, obj): | |
| self.x = x | |
| self.y = y | |
| self.x1 = 10 | |
| self.y1 = 3 | |
| self.type = 'laser' | |
| self.direction = direction | |
| self.obj = obj | |
| self.lives = 1 | |
| if self.direction % 2 == 0: | |
| self.image = self.obj.laser_2 | |
| self.x += 10 | |
| else: | |
| self.image = self.obj.laser_1 | |
| self.y += 8 | |
| if self.direction == 0: | |
| self.y -= 13 | |
| elif self.direction == 1: | |
| self.x += 23 | |
| elif self.direction == 2: | |
| self.y += 23 | |
| elif self.direction == 3: | |
| self.x -= 13 | |
| self.obj.lasers.append(self) | |
| def be(self): | |
| if self.lives: | |
| self.obj.screen.blit(self.image, (self.x - self.obj.Player.x + | |
| self.obj.screen.get_size()[0] / 2, self.y - self.obj.Player.y + | |
| self.obj.screen.get_size()[1] / 2)) | |
| if self.direction == 0: | |
| self.y -= 5 | |
| elif self.direction == 1: | |
| self.x += 5 | |
| elif self.direction == 2: | |
| self.y += 5 | |
| elif self.direction == 3: | |
| self.x -= 5 | |
| def collide(self, collidor, other): | |
| if self.lives: | |
| self.collidor = collidor | |
| self.other = other | |
| if self.collidor: | |
| if other.lives > 0: | |
| if other.type == 'wall': | |
| self.lives = 0 | |
| elif other.type == 'slug changer': | |
| pass | |
| else: | |
| self.other.lives -= 10 | |
| self.lives = 0 | |
| pygame.mixer.Sound.play(self.obj.hurt) | |
| class player: | |
| def __init__(self, x, y, images, obj, lvl_type): | |
| self.x = x | |
| self.y = y | |
| self.images = images | |
| self.x1 = 19 | |
| self.y1 = 19 | |
| self.obj = obj | |
| self.lives = 100 | |
| self.fy = 0 | |
| self.jump = 0 | |
| self.type = 'player' | |
| self.lvl_type = lvl_type | |
| self.direction = 0 | |
| self.shot_time = pygame.time.get_ticks() | |
| self.non_diable = pygame.time.get_ticks() | |
| self.laser = 20 | |
| def be(self): | |
| if self.lives > 0: | |
| if self.lvl_type == 'platform': | |
| self.fy += 0.12 | |
| self.fy = min(5, self.fy) | |
| self.fy = max(-5, self.fy) | |
| self.y += self.fy | |
| self.obj.screen.blit(self.images[self.direction], (self.obj.screen.get_size()[0] / | |
| 2, self.obj.screen.get_size()[1] / 2)) | |
| self.obj.Levels[self.obj.choosen].camera_x = self.x | |
| self.obj.Levels[self.obj.choosen].camera_y = self.y | |
| for life in range(self.lives): | |
| pygame.draw.rect(self.obj.screen, (255, 0, 0), | |
| pygame.Rect(self.obj.screen.get_size()[0] - 30, self.obj.screen.get_size()[1] - | |
| life * 5, 10, 5)) | |
| for las in range(int(self.laser)): | |
| pygame.draw.rect(self.obj.screen, (255, 255, 0), | |
| pygame.Rect(self.obj.screen.get_size()[0] - 45, self.obj.screen.get_size()[1] - | |
| las * 25, 10, 25)) | |
| if self.lvl_type == 'story': | |
| self.obj.screen.blit(self.images[self.direction], (self.x, self.y + 130)) | |
| def collide(self, collidor, other): | |
| self.collidor = collidor | |
| self.other = other | |
| self.collider = self.other.type | |
| if other.lives > 0: | |
| if self.collider == 'pointer': | |
| if self.collidor: | |
| if other.lives > 0: | |
| self.obj.Mini_game = mini_world(self.obj) | |
| self.other.lives = 0 | |
| if self.collider == 'END': | |
| if self.collidor: | |
| raise RuntimeError('There are no other levels') | |
| if self.collidor == 'upcollide': | |
| if self.fy > 0.4: | |
| if self.collider in ('jump - aware', 'jumpers', 'fallers', 'normal', 'spikes'): | |
| self.fy = -3 | |
| if self.collider in ('normal', 'spikes'): | |
| if pygame.time.get_ticks() - self.non_diable > 3000: | |
| self.lives -= 5 | |
| self.non_diable = pygame.time.get_ticks() | |
| if self.collider == 'jump - aware': | |
| self.other.lives -= 5 | |
| else: | |
| if self.collider in ('jump - aware', 'jumpers', 'fallers', 'normal', 'spikes'): | |
| other.collide('upcollide', self) | |
| if self.x < self.other.x: | |
| other.collide('leftcollide', self) | |
| self.x -= 15 | |
| else: | |
| other.collide('rightcollide', self) | |
| self.x += 15 | |
| if self.collider in ('normal', 'spikes', 'jump - aware', 'jumpers'): | |
| if pygame.time.get_ticks() - self.non_diable > 3000: | |
| self.lives -= 5 | |
| self.fy -= 3 | |
| self.non_diable = pygame.time.get_ticks() | |
| if self.collider != 'slug changer': | |
| self.y -= 0.6 | |
| if self.fy > 0: | |
| self.fy = 0 | |
| self.jump += 1 | |
| self.jump = min(7, self.jump) | |
| self.jump = max(0, self.jump) | |
| if self.collidor == 'downcollide': | |
| if self.collider != 'slug changer': | |
| self.y += 1 | |
| if self.fy < 0: | |
| self.fy = 0 | |
| if self.collider in ('jump - aware', 'jumpers', 'fallers', 'normal', 'spikes'): | |
| if pygame.time.get_ticks() - self.non_diable > 3000: | |
| self.other.fy = -3 | |
| self.lives -= 5 | |
| self.non_diable = pygame.time.get_ticks() | |
| if self.collidor == 'leftcollide': | |
| if self.collider != 'slug changer': | |
| self.x -= 3 | |
| if self.collider in ('jump - aware', 'jumpers', 'normal', 'spikes'): | |
| if pygame.time.get_ticks() - self.non_diable > 3000: | |
| self.lives -= 5 | |
| self.fy = -3 | |
| self.non_diable = pygame.time.get_ticks() | |
| if self.collidor == 'rightcollide': | |
| if self.collider != 'slug changer': | |
| self.x += 3 | |
| if self.collider in ('jump - aware', 'jumpers', 'normal', 'spikes'): | |
| if pygame.time.get_ticks() - self.non_diable > 3000: | |
| self.fy = -3 | |
| self.lives -= 5 | |
| self.non_diable = pygame.time.get_ticks() | |
| def go(self, key): | |
| self.key = key | |
| if self.key == 'up': | |
| if self.jump > 0: | |
| self.fy -= 0.6 | |
| self.jump -= 1 | |
| if self.key == 'right': | |
| self.x += 3 | |
| self.direction = 0 | |
| if self.key == 'down': | |
| self.fy += 0.5 | |
| if self.key == 'left': | |
| self.x -= 3 | |
| self.direction = 1 | |
| def fire(self): | |
| if self.laser > 0: | |
| if pygame.time.get_ticks() - self.shot_time > 2000: | |
| if self.direction == 0: | |
| self.fire_direction = 1 | |
| else: | |
| self.fire_direction = 3 | |
| self.obj.objects.append(Laser(self.x, self.y, self.fire_direction, self.obj)) | |
| self.shot_time = pygame.time.get_ticks() | |
| pygame.mixer.Sound.play(self.obj.laser) | |
| self.laser -= 1 | |
| class slug: | |
| def __init__(self, x, y, image, obj, lives): | |
| self.x = x | |
| self.y = y | |
| self.image = image | |
| self.obj = obj | |
| self.fy = 0 | |
| self.type = 'jump - aware' | |
| self.x1 = self.image.get_size()[0] | |
| self.y1 = self.image.get_size()[1] | |
| self.direction = random.randint(0, 1) | |
| self.lives = lives | |
| self.start_time = pygame.time.get_ticks() | |
| def be(self): | |
| if self.lives > 0: | |
| self.fy += 0.08 | |
| self.y += self.fy | |
| if self.direction == 0: | |
| self.x -= 1.5 | |
| else: | |
| self.x += 1.5 | |
| if self.x - self.obj.Levels[self.obj.choosen].camera_x + self.obj.screen.get_size()[0] \ | |
| / 2 < self.obj.screen.get_size()[0] and self.y - \ | |
| self.obj.Levels[self.obj.choosen].camera_y + self.obj.screen.get_size()[1] / 2 < \ | |
| self.obj.screen.get_size()[1]: | |
| self.obj.screen.blit(self.image, (self.x - | |
| self.obj.Levels[self.obj.choosen].camera_x + self.obj.screen.get_size()[0] / 2, | |
| self.y - self.obj.Levels[self.obj.choosen].camera_y + self.obj.screen.get_size()[1] | |
| / 2)) | |
| def collide(self, collidor, other): | |
| self.collidor = collidor | |
| self.other = other | |
| self.collider = self.other.type | |
| if self.collidor == 'upcollide': | |
| self.y -= 0.5 | |
| if self.fy > 0: | |
| self.fy = 0 | |
| if self.collidor == 'downcollide': | |
| self.y += 1 | |
| if self.fy < 0: | |
| self.fy = 0 | |
| if self.collidor == 'rightcollide': | |
| self.x += 1 | |
| self.direction = not self.direction | |
| if self.collidor == 'leftcollide': | |
| self.x -= 1 | |
| self.direction = not self.direction | |
| class robot: | |
| def __init__(self, x, y, image, obj, lives): | |
| self.x = x | |
| self.y = y | |
| self.image = image | |
| self.obj = obj | |
| self.fy = 0 | |
| self.type = 'normal' | |
| self.x1 = self.image.get_size()[0] | |
| self.y1 = self.image.get_size()[1] | |
| self.direction = random.randint(0, 1) | |
| self.lives = lives | |
| self.start_time = pygame.time.get_ticks() | |
| self.shot = pygame.time.get_ticks() | |
| def be(self): | |
| if self.lives > 0: | |
| self.fy += 0.08 | |
| self.y += self.fy | |
| if self.direction == 0: | |
| self.x -= 1.5 | |
| else: | |
| self.x += 1.5 | |
| if self.x - self.obj.Levels[self.obj.choosen].camera_x + self.obj.screen.get_size()[0] \ | |
| / 2 < self.obj.screen.get_size()[0] and self.y - \ | |
| self.obj.Levels[self.obj.choosen].camera_y + self.obj.screen.get_size()[1] / 2 < \ | |
| self.obj.screen.get_size()[1]: | |
| self.obj.screen.blit(self.image, (self.x - | |
| self.obj.Levels[self.obj.choosen].camera_x + self.obj.screen.get_size()[0] / 2, | |
| self.y - self.obj.Levels[self.obj.choosen].camera_y + self.obj.screen.get_size()[1] | |
| / 2)) | |
| if self.obj.Player.y + self.obj.Player.y1 > self.y and self.y + self.y1 > \ | |
| self.obj.Player.y: | |
| if self.x < self.obj.Player.x: | |
| self.direction = 1 | |
| else: | |
| self.direction = 0 | |
| self.fire() | |
| def collide(self, collidor, other): | |
| self.collidor = collidor | |
| self.other = other | |
| self.collider = self.other.type | |
| if self.collidor == 'upcollide': | |
| self.y -= 0.5 | |
| if self.fy > 0: | |
| self.fy = 0 | |
| if self.collidor == 'downcollide': | |
| self.y += 1 | |
| if self.fy < 0: | |
| self.fy = 0 | |
| if self.collidor == 'rightcollide': | |
| self.x += 1 | |
| self.direction = not self.direction | |
| if self.collidor == 'leftcollide': | |
| self.x -= 1 | |
| self.direction = not self.direction | |
| def fire(self): | |
| if pygame.time.get_ticks() - self.shot > 2000: | |
| if self.direction == 1: | |
| self.fire_direction = 1 | |
| else: | |
| self.fire_direction = 3 | |
| self.obj.objects.append(Laser(self.x, self.y, self.fire_direction, self.obj)) | |
| self.shot = pygame.time.get_ticks() | |
| # pygame.mixer.Sound.play(self.obj.laser) | |
| class END: | |
| def __init__(self, x, y, obj, image): | |
| self.x = x | |
| self.y = y | |
| self.obj = obj | |
| self.image = image | |
| self.x1 = self.image.get_size()[0] | |
| self.y1 = self.image.get_size()[1] | |
| self.type = 'END' | |
| self.lives = 1 | |
| def be(self): | |
| self.obj.screen.blit(self.image, (self.x - self.obj.Player.x + self.obj.screen.get_size() | |
| [0] / 2, self.y - self.obj.Player.y + self.obj.screen.get_size()[1] / 2)) | |
| def collide(self, collidor, other): | |
| pass | |
| class wall: | |
| def __init__(self, x, y, x1, y1): | |
| self.x = x | |
| self.y = y | |
| self.x1 = x1 | |
| self.y1 = y1 | |
| self.type = 'wall' | |
| self.lives = 1 | |
| def collide(self, collidor, collider): | |
| pass | |
| class slug_changer: | |
| def __init__(self, x, y, x1, y1): | |
| self.x = x | |
| self.y = y | |
| self.x1 = x1 | |
| self.y1 = y1 | |
| self.type = 'slug changer' | |
| self.lives = 1 | |
| def collide(self, collidor, collider): | |
| pass | |
| class pointer: | |
| def __init__(self, x, y, obj, images): | |
| self.x = x | |
| self.y = y | |
| self.x1 = 50 | |
| self.y1 = 50 | |
| self.obj = obj | |
| self.images = images | |
| self.type = 'pointer' | |
| self.anime = 0 | |
| self.lives = 1 | |
| self.time = pygame.time.get_ticks() | |
| def be(self): | |
| self.ix = self.images[self.anime].get_size()[0] - 50 | |
| self.iy = self.images[self.anime].get_size()[1] - 50 | |
| self.obj.screen.blit(self.images[self.anime], (self.x - int(self.ix / 2) - self.obj.Player.x | |
| + self.obj.screen.get_size()[0] / 2, self.y - int(self.iy / 2) - self.obj.Player.y + | |
| self.obj.screen.get_size()[1] / 2)) | |
| if pygame.time.get_ticks() - self.time > 100: | |
| self.anime += 1 | |
| if self.anime == 9: | |
| self.anime = 0 | |
| self.time = pygame.time.get_ticks() | |
| def collide(self, collidor, other): | |
| pass | |
| class mini_world: | |
| def __init__(self, obj): | |
| self.obj = obj | |
| self.type = random.choice(['flyer']) | |
| self.obj.state = 'mini world' | |
| if self.type == 'flyer': | |
| self.Player = self.obj.spaceship | |
| self.anime = False | |
| self.screen = self.obj.screens[0] | |
| self.y = 150 | |
| self.walls = [] | |
| self.x = -700 | |
| self.dis = 0 | |
| while self.x < 0: | |
| self.dis += 1 | |
| self.x += 1 | |
| if self.dis > 140: | |
| self.choice = random.randint(0, 2) | |
| if self.choice == 0: | |
| self.walls.append(wall(800 + self.x, 0, random.randint(30, 60), | |
| random.randint(80, 110))) | |
| elif self.choice == 1: | |
| self.g = random.randint(30, 60) | |
| self.h = random.randint(80, 110) | |
| self.walls.append(wall(800 + self.x, 300 - self.h, self.g, self.h)) | |
| else: | |
| self.g = random.randint(30, 60) | |
| self.h = random.randint(80, 110) | |
| self.walls.append(wall(800 + self.x, 150 - self.h / 2, self.g, self.h)) | |
| self.dis = 0 | |
| self.speed = 3 | |
| self.x = -100 | |
| def be(self): | |
| if self.type == 'flyer': | |
| self.x += self.speed | |
| self.player = wall(35, self.y - 5, 20, 10) | |
| self.obj.screen.blit(self.screen, (self.obj.screen.get_size()[0] / 2 - 405, | |
| self.obj.screen.get_size()[1] / 2 - 155)) | |
| self.obj.screen.blit(self.Player[self.anime], (self.obj.screen.get_size()[0] / 2 - 370, | |
| self.y + self.obj.screen.get_size()[1] / 2 - 150)) | |
| self.press = self.obj.press | |
| if self.press[pygame.K_DOWN]: | |
| self.y += 3 | |
| if self.press[pygame.K_UP]: | |
| self.y -= 3 | |
| for wll in self.walls: | |
| wll.x -= self.speed | |
| pygame.draw.rect(self.obj.screen, (255, 0, 0), pygame.Rect(wll.x + | |
| self.obj.screen.get_size()[0] / 2 - 400, wll.y + self.obj.screen.get_size()[1] / 2 - | |
| 150, wll.x1, wll.y1)) | |
| if collide(self.player, wll): | |
| self.obj.screen.blit(self.Player[2], (35, self.y - 5)) | |
| pygame.display.flip() | |
| pygame.time.wait(500) | |
| self.obj.state = None | |
| self.obj.Mini_game = None | |
| self.obj.Player.laser += self.x // 250 | |
| self.obj.Player.laser = min(20, self.obj.Player.laser) | |
| if self.y > 280 or self.y < 0: | |
| self.obj.screen.blit(self.Player[2], (35, self.y - 5)) | |
| pygame.display.flip() | |
| pygame.time.wait(500) | |
| self.obj.state = None | |
| self.obj.Mini_game = None | |
| self.obj.Player.laser += self.x // 250 | |
| self.obj.Player.laser = min(20, self.obj.Player.laser) | |
| for wll in range(len(self.walls) - 1): | |
| if self.walls[wll].x + self.walls[wll].x1 < 0: | |
| del self.walls[wll] | |
| self.dis += 3 | |
| self.speed += 0.01 | |
| if self.dis > 140: | |
| self.choice = random.randint(0, 2) | |
| if self.choice == 0: | |
| self.walls.append(wall(800 + self.x, 0, random.randint(30, 60), | |
| random.randint(80, 110))) | |
| elif self.choice == 1: | |
| self.g = random.randint(30, 60) | |
| self.h = random.randint(80, 110) | |
| self.walls.append(wall(800 + self.x, 300 - self.h, self.g, self.h)) | |
| else: | |
| self.g = random.randint(30, 60) | |
| self.h = random.randint(80, 110) | |
| self.walls.append(wall(800 + self.x, 150 - self.h / 2, self.g, self.h)) | |
| self.dis -= 140 | |
| if self.x > 5000: | |
| self.obj.state = None | |
| self.obj.Mini_game = None | |
| self.obj.Player.laser = 20 | |
| self.anime = not self.anime | |
| class Level: | |
| def __init__(self, tilemap, obj, type, background): | |
| self.tilemap = tilemap | |
| self.obj = obj | |
| self.type = type | |
| self.background = pygame.transform.scale(background, self.obj.screen.get_size()).convert() | |
| self.camera_x = 0 | |
| self.camera_y = 0 | |
| if self.type == 'story': | |
| self.camera_y = -300 | |
| self.convers = [] | |
| self.convers.append(['boy', 'Hello!']) | |
| self.convers.append(['old', 'Hello you young c-borg zombie.']) | |
| self.convers.append(['old', 'I am your teacher now!']) | |
| self.convers.append(['boy', 'And why will you teach me?']) | |
| self.convers.append(['old', 'Because of mission.']) | |
| self.convers.append(['boy', 'What mission?']) | |
| self.convers.append(['old', 'Mission of connecting worlds in war.']) | |
| self.convers.append(['boy', 'And who are YOU exactly???']) | |
| self.convers.append(['old', 'I am wizard.']) | |
| self.convers.append(['boy', 'Is your name Gandalf?']) | |
| self.convers.append(['old', 'Oh, how will I teach you?']) | |
| self.convers.append(['old', 'You are so stupid!']) | |
| self.convers.append(['boy', 'God trick.']) | |
| self.convers.append(['boy', 'How did you did that?']) | |
| self.convers.append(['boy', 'Teacher?']) | |
| self.convers.append(['boy', 'You are realy dead?']) | |
| self.convers.append(['boy', '!#@\^*@']) | |
| self.counter = 0 | |
| self.letter = 0 | |
| self.time = pygame.time.get_ticks() | |
| self.level = tiledtmxloader.tmxreader.TileMapParser().parse_decode(tilemap) | |
| self.resources = tiledtmxloader.helperspygame.ResourceLoaderPygame() | |
| self.resources.load(self.level) | |
| self.display = tiledtmxloader.helperspygame.RendererPygame() | |
| self.objs = tiledtmxloader.helperspygame.get_layers_from_map(self.resources) | |
| for obj in self.objs: | |
| if obj.is_object_group: | |
| if obj.name == 'walls': | |
| for some in obj.objects: | |
| self.obj.walls.append(wall(some.x, some.y, some.width, some.height)) | |
| if obj.name == 'characters': | |
| for some in obj.objects: | |
| if some.name == 'player': | |
| self.obj.Player = player(some.x, some.y, self.obj.players, self.obj, | |
| self.type) | |
| self.obj.objects.append(self.obj.Player) | |
| if some.name == 'slug': | |
| self.obj.enemies.append(slug(some.x, some.y, self.obj.slug1, self.obj, | |
| 5)) | |
| if some.name == 'slug2': | |
| self.obj.enemies.append(slug(some.x, some.y, self.obj.slug2, self.obj, | |
| 10)) | |
| if some.name == 'slug3': | |
| self.obj.enemies.append(slug(some.x, some.y, self.obj.slug3, self.obj, | |
| 15)) | |
| if some.name == 'robot': | |
| self.obj.enemies.append(robot(some.x, some.y, self.obj.robot1, | |
| self.obj, 10)) | |
| if some.name == 'robot2': | |
| self.obj.enemies.append(robot(some.x, some.y, self.obj.robot2, | |
| self.obj, 20)) | |
| if some.name == 'old man': | |
| self.obj.old_man = player(some.x, some.y, self.obj.old, self.obj, | |
| self.type) | |
| if obj.name == 'mini worlds': | |
| for some in obj.objects: | |
| self.obj.Mini_worlds.append(pointer(some.x, some.y, self.obj, | |
| self.obj.mini_worlds)) | |
| if obj.name == 'slug changer': | |
| for some in obj.objects: | |
| self.obj.walls.append(slug_changer(some.x, some.y, some.width, some.height)) | |
| if obj.name == 'End': | |
| for some in obj.objects: | |
| self.obj.end = END(some.x, some.y, self.obj, self.obj.Final) | |
| def be(self): | |
| self.obj.screen.blit(self.background, (0, 0)) | |
| for obj in self.objs: | |
| if obj.is_object_group: | |
| pass | |
| else: | |
| self.display.render_layer(self.obj.screen, obj) | |
| if self.type == 'story': | |
| self.display.set_camera_position_and_size(self.camera_x, self.camera_y, | |
| self.obj.screen.get_size()[0], self.obj.screen.get_size()[1], "topleft") | |
| pygame.draw.rect(self.obj.screen, (0, 0, 0), pygame.Rect(0, self.obj.screen.get_size() | |
| [1] * 0.65, self.obj.screen.get_size()[0], self.obj.screen.get_size()[1] * 0.35)) | |
| pygame.draw.rect(self.obj.screen, (255, 255, 255), pygame.Rect(0, | |
| self.obj.screen.get_size()[1] * 0.65, self.obj.screen.get_size()[0], | |
| self.obj.screen.get_size()[1] * 0.35), 5) | |
| pygame.draw.line(self.obj.screen, (255, 255, 255), (0, int(self.obj.screen.get_size()[1] | |
| * 0.65) + 10), (self.obj.screen.get_size()[0], int(self.obj.screen.get_size()[1] * 0.65) | |
| + 10), 2) | |
| if self.counter == 11: | |
| if self.letter == 1: | |
| self.obj.old_man.direction = 1 | |
| elif self.letter == 5: | |
| self.obj.old_man.direction = 2 | |
| elif self.letter == 9: | |
| self.obj.old_man.direction = 3 | |
| elif self.letter == 12: | |
| self.obj.old_man.direction = 4 | |
| elif self.letter == 18: | |
| self.obj.old_man.direction = 5 | |
| pygame.mixer.Sound.play(self.obj.gun) | |
| if pygame.time.get_ticks() - self.time > 150: | |
| self.letter += 1 | |
| if len(self.convers[self.counter][1]) < self.letter: | |
| self.letter = 0 | |
| self.counter += 1 | |
| self.time = pygame.time.get_ticks() | |
| if self.counter == 17: | |
| self.obj.choosen = 0 | |
| self.obj.objects = [] | |
| self.obj.enemies = [] | |
| self.obj.walls = [] | |
| self.obj.lasers = [] | |
| self.obj.Mini_worlds = [] | |
| self.obj.Levels[0].__init__(self.obj.Levels[0].tilemap, self.obj, 'platform', | |
| self.obj.Levels[0].background) | |
| self.obj.screen.fill((random.randint(0, 255), random.randint(0, 255), | |
| random.randint(0, 255))) | |
| pygame.time.wait(500) | |
| pygame.display.flip() | |
| self.obj.objects += self.obj.enemies | |
| self.obj.objects += self.obj.walls | |
| self.obj.objects += self.obj.Mini_worlds | |
| else: | |
| self.text = self.obj.normal.render(self.convers[self.counter][1][:self.letter], 1, | |
| (255, 255, 255)) | |
| if self.convers[self.counter][0] == 'boy': | |
| self.obj.screen.blit(self.text, (20, int(self.obj.screen.get_size()[1] * 0.75))) | |
| else: | |
| self.obj.screen.blit(self.text, (int(self.obj.screen.get_size()[0] - | |
| self.text.get_size()[0] - 20), int(self.obj.screen.get_size()[1] * 0.75))) | |
| else: | |
| self.display.set_camera_position_and_size(self.camera_x, self.camera_y, | |
| self.obj.screen.get_size()[0], self.obj.screen.get_size()[1], "center") | |
| class game: | |
| def __init__(self): | |
| self.screen = pygame.display.set_mode((0, 0), FULLSCREEN) | |
| self.running = True | |
| self.play = False | |
| self.state = None | |
| pygame.init() | |
| self.mouse = False | |
| self.objects = [] | |
| self.walls = [] | |
| self.enemies = [] | |
| self.lasers = [] | |
| self.Mini_worlds = [] | |
| self.Mini_game = None | |
| self.choosen = 'story' | |
| self.normal = pygame.font.Font('GnomeBits.ttf', 44) | |
| self.exit_text = self.normal.render('Exit', 1, (0, 0, 0)) | |
| self.exit = pusher(550, 600, self.exit_text, self, 'blackscreen', time=5000) | |
| self.start_text = self.normal.render('Start', 1, (40, 40, 40)) | |
| self.start = pusher(550, 200, self.start_text, self, 'shine', time=3000) | |
| self.main_text = self.normal.render('Main Menu', 1, (20, 20, 20)) | |
| self.main_menu = pusher(550, 400, self.main_text, self, 'menu', proces=0) | |
| self.continue_text = self.normal.render('Continue', 1, (40, 40, 40)) | |
| self.Continue = pusher(550, 200, self.continue_text, self, 'continue', proces=0) | |
| self.levels_text = self.normal.render('Levels', 1, (20, 20, 20)) | |
| self.levels = pusher(550, 400, self.levels_text, self, 'levels') | |
| self.story_text = self.normal.render('Story', 1, (0, 0, 0)) | |
| self.story_shine = self.normal.render('Story', 1, (128, 128, 128)) | |
| self.story_choosen = self.normal.render('Story', 1, (170, 170, 170)) | |
| self.story = pusher(550, self.screen.get_size()[1] - 50, self.story_text, self, 'story', | |
| pos_do='story shine', anti_pos_do='anti story shine', infinity=1, proces=0) | |
| self.nums = [] | |
| self.shine_nums = [] | |
| self.level_choosers = [] | |
| self.choosen_nums = [] | |
| for lvl in range(50): | |
| self.nums.append(self.normal.render(str(lvl + 1), 1, (0, 0, 0))) | |
| self.shine_nums.append(self.normal.render(str(lvl + 1), 1, (128, 128, 128))) | |
| self.choosen_nums.append(self.normal.render(str(lvl + 1), 1, (170, 170, 170))) | |
| self.x = 20 | |
| self.y = 20 | |
| self.x += lvl * 50 | |
| while self.x + self.nums[lvl].get_size()[0] > self.screen.get_size()[0]: | |
| self.x -= self.screen.get_size()[0] - 20 | |
| self.y += 50 | |
| self.level_choosers.append(pusher(self.x, self.y, self.nums[lvl], self, 'level' + | |
| str(lvl), pos_do='level shine' + str(lvl), anti_pos_do='level anti shine' + str(lvl), | |
| infinity=1, proces=0)) | |
| self.slug1 = pygame.image.load('slug1.png') | |
| self.slug2 = pygame.image.load('slug2.png') | |
| self.slug3 = pygame.image.load('slug3.png') | |
| self.robot1 = pygame.image.load('robot1.png') | |
| self.robot2 = pygame.image.load('robot2.png') | |
| self.Final = pygame.image.load('END.bmp') | |
| self.players = [] | |
| self.players.append(pygame.image.load('player_1.png')) | |
| self.players.append(pygame.image.load('player_2.png')) | |
| self.old = [] | |
| self.old.append(pygame.image.load('old_man.png')) | |
| self.old.append(pygame.image.load('old_man_firing_1.png')) | |
| self.old.append(pygame.image.load('old_man_firing_2.png')) | |
| self.old.append(pygame.image.load('old_man_firing_3.png')) | |
| self.old.append(pygame.image.load('old_man_firing_4.png')) | |
| self.old.append(pygame.image.load('old_man_firing_5.png')) | |
| self.laser_1 = pygame.image.load('laser_1.bmp') | |
| self.hurt = pygame.mixer.Sound('hurt.wav') | |
| self.laser = pygame.mixer.Sound('laser.wav') | |
| self.gun = pygame.mixer.Sound('gun.wav') | |
| self.background1 = pygame.image.load('mor.png') | |
| self.background2 = pygame.image.load('day.png') | |
| self.mini_worlds = [] | |
| for world in range(1, 10): | |
| self.mini_worlds.append(pygame.image.load('mini_world_' + str(world) + '.png')) | |
| self.story_level = Level('story.tmx', self, 'story', self.background1) | |
| self.tilemaps = [] | |
| self.tilemaps.append("first_level.tmx") | |
| self.Levels = [] | |
| self.Levels.append(Level(self.tilemaps[0], self, 'platform', self.background2)) | |
| self.spaceship = [] | |
| self.spaceship.append(pygame.image.load('spaceship_1.png')) | |
| self.spaceship.append(pygame.image.load('spaceship_2.png')) | |
| self.spaceship.append(pygame.image.load('spaceship_3.png')) | |
| self.screens = [] | |
| self.screens.append(pygame.image.load('screen1.bmp')) | |
| self.clock = pygame.time.Clock() | |
| def main(self): | |
| while self.running: | |
| for event in pygame.event.get(): | |
| if event.type == pygame.QUIT: | |
| self.running = False | |
| if event.type == pygame.MOUSEBUTTONDOWN: | |
| self.mouse = True | |
| else: | |
| self.mouse = False | |
| if event.type == KEYDOWN: | |
| if event.key == pygame.K_ESCAPE: | |
| self.play = False | |
| self.exit.recall() | |
| if self.story.proces: | |
| self.start.recall() | |
| self.levels.recall() | |
| for lvl in self.level_choosers: | |
| lvl.proces = 0 | |
| self.story.proces = 0 | |
| else: | |
| self.Continue.recall() | |
| self.main_menu.recall() | |
| if event.key == pygame.K_RCTRL: | |
| if self.play: | |
| self.Player.fire() | |
| self.screen.fill((255, 255, 255)) | |
| if self.play: | |
| if self.choosen == 'story': | |
| self.story_level.be() | |
| self.old_man.be() | |
| else: | |
| self.Levels[self.choosen].be() | |
| self.end.be() | |
| self.press = pygame.key.get_pressed() | |
| if self.press[pygame.K_UP]: | |
| self.Player.go('up') | |
| if self.press[pygame.K_RIGHT]: | |
| self.Player.go('right') | |
| if self.press[pygame.K_DOWN]: | |
| self.Player.go('down') | |
| if self.press[pygame.K_LEFT]: | |
| self.Player.go('left') | |
| if self.state == 'mini world': | |
| self.screen.blit(self.Player.images[self.Player.direction], | |
| (self.screen.get_size()[0] / 2, self.screen.get_size()[1] / 2)) | |
| else: | |
| self.Player.be() | |
| for world in self.Mini_worlds: | |
| world.be() | |
| self.Player.collide(collide(self.Player, world), world) | |
| for enemy in self.enemies: | |
| if self.state == 'mini world': | |
| self.screen.blit(enemy.image, (self.x - self.Player.x + | |
| self.screen.get_size()[0] / 2, self.y - self.Player.y + | |
| self.screen.get_size()[1] / 2)) | |
| else: | |
| enemy.be() | |
| if not self.state: | |
| for wll in self.walls: | |
| self.Player.collide(collide(self.Player, wll), wll) | |
| for enemy in self.enemies: | |
| enemy.collide(collide(enemy, wll), wll) | |
| for lass in self.lasers: | |
| lass.collide(collide(lass, wll), wll) | |
| for shoot in self.lasers: | |
| if shoot.lives > 0: | |
| shoot.be() | |
| shoot.collide(collide(shoot, self.Player), self.Player) | |
| for enemy in self.enemies: | |
| shoot.collide(collide(shoot, enemy), enemy) | |
| self.Player.collide(collide(self.Player, self.end), self.end) | |
| for enemy in self.enemies: | |
| self.Player.collide(collide(self.Player, enemy), enemy) | |
| enemy.collide(collide(enemy, self.Player), self.Player) | |
| if self.Mini_game: | |
| self.Mini_game.be() | |
| for lvl in self.level_choosers: | |
| lvl.be() | |
| self.exit.be() | |
| self.start.be() | |
| self.levels.be() | |
| self.main_menu.be() | |
| self.Continue.be() | |
| self.story.be() | |
| pygame.display.flip() | |
| self.clock.tick(65) | |
| def change(self, what): | |
| self.what = what | |
| if self.what == 'blackscreen': | |
| self.all = 255 | |
| while self.running: | |
| self.screen.fill((self.all, self.all, self.all)) | |
| self.exit.be() | |
| self.levels.be() | |
| self.start.be() | |
| self.all -= 1 | |
| if self.all == 0: | |
| self.running = False | |
| pygame.display.flip() | |
| if self.what == 'shine': | |
| self.screen.fill((random.randint(0, 255), random.randint(0, 255), | |
| random.randint(0, 255))) | |
| pygame.display.flip() | |
| pygame.time.wait(500) | |
| self.objects = [] | |
| self.enemies = [] | |
| self.walls = [] | |
| self.lasers = [] | |
| self.Mini_worlds = [] | |
| if self.choosen == 'story': | |
| self.story_level.__init__(self.story_level.tilemap, self, 'story', self.background1) | |
| else: | |
| self.Levels[self.choosen].__init__(self.Levels[self.choosen].tilemap, self, | |
| self.Levels[self.choosen].type, self.Levels[self.choosen].background) | |
| self.play = True | |
| self.objects += self.enemies | |
| self.objects += self.walls | |
| self.objects += self.Mini_worlds | |
| self.exit.proces = 0 | |
| self.levels.proces = 0 | |
| if self.what == 'menu': | |
| self.start.recall() | |
| self.levels.recall() | |
| del self.Player | |
| del self.enemies | |
| del self.objects | |
| del self.walls | |
| del self.Mini_worlds | |
| self.Continue.proces = 0 | |
| if self.what == 'continue': | |
| self.main_menu.proces = 0 | |
| self.exit.proces = 0 | |
| self.play = True | |
| if self.what == 'levels': | |
| self.start.proces = 0 | |
| self.exit.proces = 0 | |
| for lvl in self.level_choosers: | |
| lvl.recall() | |
| self.story.recall() | |
| if self.what == 'story shine': | |
| self.story.update(550, self.screen.get_size()[1] - 50, self.story_shine, self, 'story', | |
| pos_do='story shine', anti_pos_do='anti story shine', infinity=1) | |
| if self.what == 'anti story shine': | |
| self.story.update(550, self.screen.get_size()[1] - 50, self.story_text, self, 'story', | |
| pos_do='story shine', anti_pos_do='anti story shine', infinity=1) | |
| if self.choosen == 'story': | |
| self.story.update(550, self.screen.get_size()[1] - 50, self.story_choosen, self, | |
| 'story', pos_do='story shine', anti_pos_do='anti story shine', infinity=1) | |
| if self.what == 'story': | |
| self.choosen = 'story' | |
| if self.what: | |
| if len(self.what) > 11: | |
| if self.what[:11] == 'level shine': | |
| self.level_choosers[int(self.what[11:])].update( | |
| self.level_choosers[int(self.what[11:])].x1, | |
| self.level_choosers[int(self.what[11:])].y1, self.shine_nums | |
| [int(self.what[11:])], self, 'level' + self.what[11:], pos_do=self.what, | |
| anti_pos_do='level anti shine' + self.what[11:], infinity=1) | |
| if len(self.what) > 16: | |
| if self.what[:16] == 'level anti shine': | |
| self.level_choosers[int(self.what[16:])].update( | |
| self.level_choosers[int(self.what[16:])].x1, | |
| self.level_choosers[int(self.what[16:])].y1, self.nums[int(self.what[16:])], | |
| self, 'level' + self.what[16:], pos_do='level shine' + self.what[16:], | |
| anti_pos_do=self.what, infinity=1) | |
| if self.choosen == int(self.what[16:]): | |
| self.level_choosers[int(self.what[16:])].update( | |
| self.level_choosers[int(self.what[16:])].x1, | |
| self.level_choosers[int(self.what[16:])].y1, self.choosen_nums | |
| [int(self.what[16:])], self, 'level' + self.what[16:], | |
| pos_do='level choosen' + self.what[16:], anti_pos_do=self.what, infinity=1) | |
| if len(self.what) > 5: | |
| if self.what[5] not in ('s', ' '): | |
| if self.what[:5] == 'level': | |
| self.choosen = int(self.what[5:]) | |
| Game = game() | |
| Game.main() |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment