Club Penguin Sledding Game

CPSled.py

@@ -0,0 +1,269 @@
+#THIS FILE IS DOPE
+import pygame
+from pygame.locals import *
+import time
+from random import *
+clock = pygame.time.Clock()
+
+class Penguin(pygame.sprite.Sprite):
+    """
+    Penguin is the sprite that the user controls using the left and right arrows
+    It moves up and down (respectively) the screen
+    """
+    def __init__(self):
+        # Call the parent class (Sprite) constructor
+        super().__init__()
+        self.image = pygame.image.load("penguin_smol.png")
+        self.rect = self.image.get_rect()
+        self.rect.y = 170
+
+    def moveUp(self, pixels):
+        if self.rect.y <= 0:
+            self.rect.y = 0
+        else:
+            self.rect.y -= pixels
+    def moveDown(self, pixels):
+        if self.rect.y >= 340:
+            self.rect.y = 340
+        else:
+            self.rect.y += pixels
+
+class Obstacles(pygame.sprite.Sprite):
+    """
+    Obstacles is the parent class of the many different types of obstacles
+    The obstacles continuously move towards the left of the screen (at varying speeds),
+    giving the impression that the penguin is moving towards the right of the screen
+    """
+    def __init__(self, image_name, rect = None):
+        super().__init__()
+        self.image = pygame.image.load(image_name)
+        self.rect = self.image.get_rect()
+        if rect != None:
+            self.rect = rect
+
+    def moveLeft(self, pixels = 7):
+        self.rect.x -= pixels
+    def slowDown(self, pixels = 3):
+        self.rect.x -= pixels
+    def speedUp(self, pixels = 10):
+        self.rect.x -= pixels
+
+class Powerups(Obstacles):
+    """
+    PowerUps inherits from Obstacles and makes the obstacles move faster across the screen,
+    making it seem like the penguin is speeding up
+    """
+    def speedUp(self, pixels = 10):
+        self.rect.x -= pixels
+
+class FinishLine(Obstacles):
+    pass
+
+class Bump(Obstacles):
+    pass
+
+class Log(Obstacles):
+    pass
+
+class Ramp(Obstacles):
+    pass
+
+class KeyController(object):
+    """
+    allows the player to move the penguin using the left and right keys
+    """
+    def __init__(self, model):
+        self.model = model
+
+    def event_type(self, keys, state): #state determines whether the penguin hit an obstacle or powerup
+        if keys[pygame.K_LEFT] and state == 1:
+            #if penguin hits obstacle, prevent the player from moving off the obstacle by "disabling" the keyboard controls
+            self.model.penguin.moveUp(0)
+        if keys[pygame.K_RIGHT] and state == 1:
+            self.model.penguin.moveDown(0)
+        if keys[pygame.K_LEFT] and state == 2:
+            #if the penguin hits a powerup, the player can still potentially move off the powerup (just to add a bit more challenge)
+            self.model.penguin.moveUp(5)
+        if keys[pygame.K_RIGHT] and state == 2:
+            self.model.penguin.moveDown(5)
+
+class CPSledView(object):
+    """
+    View class draws all the sprites/screens that the model class updates
+    """
+    def __init__(self, model, width, height):
+        self.model = model
+        size = (width, height) #viewing frame is 500 x 400 pixels
+        self.model.WHITE = pygame.Color(255, 255, 255)
+        self.model.screen = pygame.display.set_mode(size)
+
+    def draw(self, model, timer):
+        self.model = model
+        self.model.screen.blit(timer, (425, 20))
+        self.model.boulders.draw(self.model.screen)
+        self.model.ice_patches.draw(self.model.screen)
+        self.model.bumps.draw(self.model.screen)
+        self.model.logs.draw(self.model.screen)
+        self.model.ramps.draw(self.model.screen)
+        self.model.all_penguins.draw(self.model.screen)
+        self.model.finish_line_group.draw(self.model.screen)
+        pygame.display.update()
+
+class CPSledModel(object):
+    """
+    Model class updates as the player control the sprite
+    Creates all the sprites
+    Randomly generates a track of obstacles
+    """
+    def __init__(self, width, height):
+        pygame.init()
+        size = (width, height)
+        self.WHITE = pygame.Color(255, 255, 255)
+        self.screen = pygame.display.set_mode(size)
+        self.height = height
+        self.width = width
+
+    def loadSprites(self):
+        self.penguin = Penguin()
+        #self.penguin.image = pygame.transform.rotate(self.penguin.image, -30)
+        self.all_penguins = pygame.sprite.RenderPlain(self.penguin)
+        self.boulders = pygame.sprite.RenderPlain()
+        self.ice_patches = pygame.sprite.RenderPlain()
+        self.finish_line_group = pygame.sprite.RenderPlain()
+        self.bumps = pygame.sprite.RenderPlain()
+        self.logs = pygame.sprite.RenderPlain()
+        self.ramps = pygame.sprite.RenderPlain()
+
+        for num_boulders in range(18): #creating 20 boulders
+            x_position = (num_boulders+1) * randint(410, 440) #randomly generate an x-position within a certain range
+            y_boulders = randint(1,3) #randomly decide how many boulders to put in a straight line
+            for i in range(y_boulders):
+                y_position = randrange(0, 340, 70) #randomly choose a y-position for each boulder
+                self.boulder = Obstacles("rock.png", pygame.Rect(x_position, y_position, 60, 60))
+                self.boulder.rect.inflate(0, -10)
+                self.boulders.add(self.boulder) #add boulder to the boulder sprite group
+
+        for num_ice_patches in range(13):
+            x_position = (num_ice_patches+1) * randint(640, 670)
+            y_position = randint(0, 340)
+            self.ice_patch = Powerups("ice_patch_flat.png", pygame.Rect(x_position, y_position, 280, 70))
+            self.ice_patches.add(self.ice_patch)
+
+        for num_bumps in range(12):
+            x_position = (num_bumps + 1) * randint(710, 730)
+            y_position = randint(0, 300)
+            self.bump = Bump("bump.png", pygame.Rect(x_position, y_position, 132, 98))
+            self.bumps.add(self.bump)
+
+        for num_logs in range(6):
+            x_position = (num_logs+1) * 1100
+            y_position = 0
+            self.log = Log("log.png", pygame.Rect(x_position, y_position, 170, 400))
+            self.logs.add(self.log)
+            self.ramp = Ramp("log_jump_test.png", pygame.Rect(x_position, 110,  170, 167))
+            self.ramps.add(self.ramp)
+
+        self.finish_line = FinishLine("finish_line.png", pygame.Rect(8750, -2, 144, 404))
+        self.finish_line_group.add(self.finish_line)
+
+    def update(self):
+        self.all_penguins.update()
+        self.boulders.update()
+        self.ice_patches.update()
+        self.bumps.update()
+        self.screen.fill(self.WHITE)
+
+if __name__ == '__main__':
+
+    def main_loop():
+        pygame.init()
+        model = CPSledModel(500,400)
+        view = CPSledView(model, 500, 400)
+        controller = KeyController(model)
+        model.loadSprites()
+        #create a master list of all the randomly generated obstacles
+        list_of_obstacles = model.boulders.sprites()
+        list_of_obstacles.extend(model.ice_patches.sprites())
+        list_of_obstacles.extend(model.bumps.sprites())
+        list_of_obstacles.extend(model.logs.sprites())
+
+        #this loop parses through the master obstacle list and removes any obstacle that collides with another obstacle to minimize overlapping obstacles
+        index = 0
+        while index < (len(list_of_obstacles) - 1):
+            j = index + 1
+            while j < (len(list_of_obstacles) - 1):
+                if list_of_obstacles[index].rect.colliderect(list_of_obstacles[j].rect):
+                    list_of_obstacles.pop(j)
+                    j -= 1
+                j += 1
+            index += 1
+
+        list_of_obstacles.extend(model.ramps.sprites())
+        list_of_obstacles.append(model.finish_line)
+
+        font = pygame.font.Font(None, 32)
+        pygame.display.set_caption("Club Penguin Sledding Game")
+        running = True
+        while running:
+            #run a timer of how long the penguin takes to get to the finish line
+            current_time = str(pygame.time.get_ticks()/1000)
+            timer = font.render(current_time, True, (0,0,0))
+            for event in pygame.event.get():
+                if event.type is pygame.QUIT:
+                    running = False
+
+            #if peguin passes the finish line, then break out of loop
+            if model.penguin.rect.left > model.finish_line.rect.left+120:
+                while True:
+                    for event in pygame.event.get():
+                        if event.type is pygame.QUIT:
+                            pygame.quit()
+                        running = False
+
+            #different flags to identify which obstacle hit
+            hit = False
+            ice = False
+            finish = False
+            bump = False
+            ramp = False
+            for obstacle in list_of_obstacles:
+                if model.penguin.rect.colliderect(obstacle.rect):
+                    hit = True
+                    if type(obstacle) == Ramp:
+                        ramp = True
+                    if type(obstacle) == Powerups:
+                        ice = True
+                    elif type(obstacle) == FinishLine:
+                        finish = True
+                    elif type(obstacle) == Bump:
+                        bump = True
+
+            #using the flags, determine how the penguin responds to the obstacle hit
+            for obstacle in list_of_obstacles:
+                if ramp:
+                    obstacle.moveLeft()
+                elif ice or finish:
+                    obstacle.speedUp()
+                elif hit:
+                    if bump:
+                        obstacle.slowDown(5)
+                    else:
+                        obstacle.slowDown()
+                else:
+                    obstacle.moveLeft()
+            if hit and not ice and not finish and not ramp:
+                if not bump:
+                    model.penguin.image = pygame.image.load("fallen_penguin_smol_demanding_diego.png")
+                    controller.event_type(pygame.key.get_pressed(), 1)
+                else:
+                    controller.event_type(pygame.key.get_pressed(), 2)
+            else:
+                model.penguin.image = pygame.image.load("penguin_smol.png")
+                controller.event_type(pygame.key.get_pressed(), 2)
+
+            model.update()
+            view.draw(model, timer)
+            clock.tick_busy_loop(60)
+        pygame.quit()
+
+    main_loop()

README.md

@@ -1,2 +1,13 @@
 # InteractiveProgramming
-This is the base repo for the interactive programming project for Software Design, Spring 2018 at Olin College.
+Club Penguin Sledding Game
+In order to setup the environment to run this code, run the following in the terminal:
+  $ apt-get build-dep python-pygame
+  $ apt-get install mercurial python-dev python-numpy ffmpeg libsdl-image1.2-dev libsdl-mixer1.2-dev libsdl-ttf2.0-dev libsmpeg-dev libsdl1.2-dev libportmidi-dev libswscale-dev libavformat-dev libavcodec-dev
+  $ pip install pygame
+
+In order to run the actual code, run the following in the terminal:
+  python CPSled.py
+
+[Project Reflection](MP4_Club_Penguin_Reflection.pdf)
+
+Enjoy!

diego.py

@@ -0,0 +1,109 @@
+#THIS FILE IS DOPE
+import pygame
+from pygame.locals import *
+import time
+clock = pygame.time.Clock()
+
+class Penguin(pygame.sprite.Sprite): # code is from pygame documenta
+    # Constructor. Pass in the color of the block,
+    # and its x and y position
+    def __init__(self):
+        # Call the parent class (Sprite) constructor
+        super().__init__()
+
+        # Create an image of the block, and fill it with a color
+        self.image = pygame.image.load("penguin_smol.png")
+        self.rect = self.image.get_rect()
+    def moveUp(self, pixels):
+        if self.rect.y <= 0:
+            self.rect.y = 0
+        else:
+            self.rect.y -= pixels
+
+    def moveDown(self, pixels):
+        if self.rect.y >= 340:
+            self.rect.y = 340
+        else:
+            self.rect.y += pixels
+
+
+
+class Obstacles(pygame.sprite.Sprite):
+    def __init__(self, rect = None):
+        super().__init__()
+        self.image = pygame.image.load("rock.png")
+        self.rect = self.image.get_rect()
+        if rect != None:
+            self.rect = rect
+
+    def moveLeft(self, pixels):
+        self.rect.x -= pixels
+# class Model:
+#     def __init__(self):
+#         self.all_penguins = pygame.sprite.Group()
+#         penguin = Penguin()
+
+
+class Sled_Main:
+    def __init__(self):
+        pygame.init()
+        size = (500, 400)
+        self.WHITE = pygame.Color(255, 255, 255)
+        self.screen = pygame.display.set_mode(size)
+
+    def loadSprites(self):
+        self.penguin = Penguin()
+        self.all_penguins = pygame.sprite.RenderPlain(self.penguin)
+
+        self.boulders = pygame.sprite.RenderPlain()
+        self.boulders.add(Obstacles(pygame.Rect(100, 100, 60, 60)))
+
+    def main_loop(self):
+        self.loadSprites()
+        running = True
+        pygame.display.set_caption("Club Penguing Sledding Game")
+        while running:
+            #self._redraw()
+            for event in pygame.event.get():
+                if event.type is pygame.QUIT:
+                    running = False
+            keys = pygame.key.get_pressed()
+            if keys[pygame.K_LEFT]:
+                self.penguin.moveUp(15)
+            if keys[pygame.K_RIGHT]:
+                self.penguin.moveDown(15)
+            self.all_penguins.update()
+
+            list_of_boulders = self.boulders.sprites()
+
+
+            if self.penguin.rect.colliderect(list_of_boulders[0].rect):
+                list_of_boulders[0].moveLeft(0)
+            else:
+                list_of_boulders[0].moveLeft(1)
+            self.boulders.update()
+
+            self.screen.fill(self.WHITE)
+            self.boulders.draw(self.screen)
+            self.ice_patches.draw(self.screen)
+            self.all_penguins.draw(self.screen)
+            pygame.display.update()
+            clock.tick(60)
+        pygame.quit()
+
+
+
+
+if __name__ == '__main__':
+    game = Sled_Main()
+    game.main_loop()
+
+
+    # running = True
+    # while running:
+    #     for event in pygame.event.get():
+    #         if event.type == QUIT:
+    #             running = False
+    #     time.sleep(.001)
+    #
+    # pygame.quit()