Quinn and Grace Final Interactive Programming Project

ProjectProposal.md

@@ -0,0 +1,7 @@
+Grace and Quinn
+Interactive Programming
+
+
+
+We want to make a two player game using pygame. Our minimal vibale product is a game of pong, and the stretch goal is airhockey. We will explore two player inputs to generate a simple game output. Quinn's learning goal is to understand the pygame library and how to use github. Grace's goal is to have a deep understanding of our code and project. We are planning on using pygame as our main input library. For our mid prject check in we want to have a clear outline of our code functions and classes as well as how we will distribute the work between us. We would also liked to have started filling in some of this skeleton code. The biggest risk is trying to have two inputs to our game, when we have not yet done anything with a single interactive input.
+

README.md

@@ -1,2 +1,5 @@
 # InteractiveProgramming
 This is the base repo for the interactive programming project for Software Design, Spring 2018 at Olin College.
+To run this pong program you will need to install pygame ($pip install pygame) as well as import random into your code.
+The write up can be found here: https://github.com/gracemontagnino/InteractiveProgramming/blob/master/Pong%20Write-Up.pdf (Or just by looking at the Pong Write-Up File in the git repository.)
+To run this game use $python3 pong.py

collision.py

@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+"""
+@author: Grace Montagnino & Quinn Kelley
+"""
+
+import pygame
+import random
+
+from pygame.locals import *
+import time
+
+FPS = 50
+
+
+
+class PyGameWindowView(object):
+    """ A view of brick breaker rendered in a Pygame window """
+    def __init__(self, model, size):
+        """ Initialize the view with a reference to the model and the
+            specified game screen dimensions (represented as a tuple
+            containing the width and height """
+        self.model = model
+        self.screen = pygame.display.set_mode(size)
+        self.screenheight = pygame.display.get_surface().get_height()
+        # self.screenwidth = pygame.display.get_surface().get_width()
+    def draw(self):
+        """ Draw the current game state to the screen """
+        self.screen.fill(pygame.Color(0,0,0))
+
+        pygame.draw.rect(self.screen,
+                         pygame.Color(255, 0, 0),
+                         pygame.Rect(self.model.paddle.x,
+                                     self.model.paddle.y,
+                                     self.model.paddle.width,
+                                     self.model.paddle.height))
+        pygame.draw.rect(self.screen,
+                         pygame.Color(255, 255, 255),
+                         pygame.Rect(self.model.paddle2.x,
+                                     self.model.paddle2.y,
+                                     self.model.paddle2.width,
+                                     self.model.paddle2.height))
+        pygame.draw.rect(self.screen,
+                        pygame.Color(255, 255, 255),
+                        pygame.Rect(self.model.puck.x,
+                                    self.model.puck.y,
+                                    self.model.puck.height,
+                                    self.model.puck.width,
+                                    ))
+        font = pygame.font.Font(None, 36)
+        scoretext1=font.render("Score:"+str(self.model.puck.score1), 1,(255,255,255))
+        self.screen.blit(scoretext1, (440, 50))
+        scoretext2=font.render("Score:"+str(self.model.puck.score2), 1,(255,255,255))
+        self.screen.blit(scoretext2, (100, 50))
+        pygame.display.update()
+
+class Model(object):
+    """ Encodes a model of the game state """
+    def __init__(self, size):
+        self.paddle = Paddle(50,10,0,240)
+        self.paddle2=Paddle(50,10,630,240)
+        self.puck=Puck(10,10,10,10)
+    def update(self):
+        """ Update the game state (currently only tracking the paddle) """
+        self.paddle.update()
+        self.paddle2.update()
+        if int(self.puck.x)==int(self.paddle.x)+10 and (int(self.paddle.y)-50)<=int(self.puck.y)<=(int(self.paddle.y)+50):
+            self.puck.vx=-self.puck.vx
+            self.puckvy=-self.puck.vy
+        if int(self.puck.x)==int(self.paddle2.x)-10 and (int(self.paddle2.y)-50)<=int(self.puck.y)<=(int(self.paddle2.y)+50):
+            self.puck.vx=-self.puck.vx
+            self.puck.vy=-self.puck.vy
+        self.puck.update()
+
+    def __str__(self):
+        output_lines = []
+        # convert each brick to a string for outputting
+        output_lines.append(str(self.paddle))
+        # print one item per line
+        return "\n".join(output_lines)
+class Paddle(object):
+    """ Encodes the state of the paddle in the game """
+    def __init__(self, height, width, x, y):
+        """ Initialize a paddle with the specified height, width,
+            and position (x,y) """
+        self.height = height
+        self.width = width
+        self.x = x
+        self.y = y
+        self.vx = 0
+        self.vy = 0
+
+    def update(self):
+        """ update the state of the paddle & stops it from running off the screen"""
+        self.x += self.vx
+        self.y += self.vy
+        if self.y > 480 - self.height:
+            self.y = 480 - self.height
+        if 0 > self.y:
+            self.y = 0
+    def __str__(self):
+        return "Paddle height=%f, width=%f, x=%f, y=%f" % (self.height,
+                                                        self.width,
+                                                           self.x,
+                                                          self.y)
+
+class Puck(object):
+    """ Encodes the state of the paddle in the game """
+    def __init__(self,x,y,height,width):
+        """ Initialize a paddle with the specified height, width,
+            and position (x,y) """
+        #self.screen = pygame.display.set_mode(size)
+        self.height=height
+        self.x,self.y=320,240
+        self.width=width
+        self.vx=1
+        self.vy=0
+        self.score1=0
+        self.score2=0
+        self.vx=random.choice([-.6,-.4,-.2,.2,.4,.6])
+        self.vy=random.choice([-.6,-.4,-.2,.2,.4,.6])
+        self.rect = pygame.Rect(self.x, self.y, self.height, self.width)
+    def update(self):
+        """ update the state of the puck """
+        if self.y>=480 or self.y<=0:
+            self.vy=-self.vy
+        if self.x>640:
+            self.x,self.y=320,240
+            self.score2=self.score2+1
+            #Score2=int(self.score2)
+        if self.x<=0:
+            self.x,self.y=320,240
+            self.score1=self.score1+1
+            #font = pygame.font.Font(None, 36)
+            #Score1=int(self.score1)
+        self.x += self.vx
+        self.y+=self.vy
+    def draw(self, surface):
+        self.screen.fill(pygame.Color(0,0,0))
+        pygame.draw.rect(screen, (55,150,55), self.rect)
+        self.x = self.rect.left
+        self.y = self.rect.top
+        pygame.display.update()
+    def __str__(self):
+        return "Puck x coordinate=%f, y coordinate=%f, radius=%f, width=%f" % (self.x,
+                                                        self.y,
+                                                           self.height,
+                                                          self.w)
+
+class PyGameKeyboardController(object):
+    """ Handles keyboard input for brick breaker """
+    def __init__(self,model):
+        self.model = model
+
+    def handle_event(self,event):
+        """ arrow keys + WS modify the y position of the paddles"""
+        pressed = pygame.key.get_pressed()
+        if pressed[pygame.K_UP]:
+             self.model.paddle2.vy = -1
+        elif pressed[pygame.K_DOWN]:
+             self.model.paddle2.vy = 1
+        else:
+            self.model.paddle2.vy = 0
+        if pressed[pygame.K_w]:
+             self.model.paddle.vy = -1
+        elif pressed[pygame.K_s]:
+             self.model.paddle.vy = 1
+        else:
+            self.model.paddle.vy = 0
+
+if __name__ == '__main__':
+    pygame.init()
+
+    size = (640, 480)
+
+    model = Model(size)
+    print(model)
+    view = PyGameWindowView(model, size)
+    controller = PyGameKeyboardController(model)
+
+    running = True
+    while running:
+        for event in pygame.event.get():
+            if event.type == QUIT:
+                running = False
+        controller.handle_event(event)
+        screen = pygame.display.set_mode(size)
+        screen.fill((0, 0, 0))
+        model.update()
+        view.draw()
+        time.sleep(.001)
+time.sleep(.001)
+
+pygame.quit()

middle.py

@@ -0,0 +1,176 @@
+# -*- coding: utf-8 -*-
+"""
+@author: Grace Montagnino & Quinn Kelley
+"""
+
+import pygame
+import random
+
+from pygame.locals import *
+import time
+
+FPS = 50
+
+class PyGameWindowView(object):
+    """ A view of brick breaker rendered in a Pygame window """
+    def __init__(self, model, size):
+        """ Initialize the view with a reference to the model and the
+            specified game screen dimensions (represented as a tuple
+            containing the width and height """
+        self.model = model
+        self.screen = pygame.display.set_mode(size)
+        self.screenheight = pygame.display.get_surface().get_height()
+        # self.screenwidth = pygame.display.get_surface().get_width()
+    def draw(self):
+        """ Draw the current game state to the screen """
+        self.screen.fill(pygame.Color(0,0,0))
+
+        pygame.draw.rect(self.screen,
+                         pygame.Color(255, 0, 0),
+                         pygame.Rect(self.model.paddle.x,
+                                     self.model.paddle.y,
+                                     self.model.paddle.width,
+                                     self.model.paddle.height))
+        pygame.draw.rect(self.screen,
+                         pygame.Color(255, 255, 255),
+                         pygame.Rect(self.model.paddle2.x,
+                                     self.model.paddle2.y,
+                                     self.model.paddle2.width,
+                                     self.model.paddle2.height))
+        pygame.draw.rect(self.screen,
+                        pygame.Color(255, 255, 255),
+                        pygame.Rect(self.model.puck.x,
+                                    self.model.puck.y,
+                                    self.model.puck.height,
+                                    self.model.puck.width,
+                                    ))
+        pygame.display.update()
+
+class Model(object):
+    """ Encodes a model of the game state """
+    def __init__(self, size):
+        self.paddle = Paddle(50,10,0,240)
+        self.paddle2=Paddle(50,10,630,240)
+        self.puck=Puck(10,10,10,10)
+    def update(self):
+        """ Update the game state (currently only tracking the paddle) """
+        self.paddle.update()
+        self.paddle2.update()
+        if self.puck.x==(self.paddle.x+10) and self.puck.y==(self.paddle.y):
+            self.puck.vx=-self.puck.vx
+            self.puckvy=-self.puck.vy
+        if self.puck.x==(self.paddle2.x+10) and self.puck.y==(self.paddle2.y):
+            self.puck.vx=-self.puck.vx
+            self.puck.vy=-self.puck.vy
+        self.puck.update()
+    def __str__(self):
+        output_lines = []
+        # convert each brick to a string for outputting
+        output_lines.append(str(self.paddle))
+        # print one item per line
+        return "\n".join(output_lines)
+class Paddle(object):
+    """ Encodes the state of the paddle in the game """
+    def __init__(self, height, width, x, y):
+        """ Initialize a paddle with the specified height, width,
+            and position (x,y) """
+        self.height = height
+        self.width = width
+        self.x = x
+        self.y = y
+        self.vx = 0
+        self.vy = 0
+
+    def update(self):
+        """ update the state of the paddle & stops it from running off the screen"""
+        self.x += self.vx
+        self.y += self.vy
+        if self.y > 480 - self.height:
+            self.y = 480 - self.height
+        if 0 > self.y:
+            self.y = 0
+
+
+    def __str__(self):
+        return "Paddle height=%f, width=%f, x=%f, y=%f" % (self.height,
+                                                        self.width,
+                                                           self.x,
+                                                          self.y)
+
+class Puck(object):
+    """ Encodes the state of the paddle in the game """
+    def __init__(self,x,y,height,width):
+        """ Initialize a paddle with the specified height, width,
+            and position (x,y) """
+        self.height=height
+        self.x,self.y=320,240
+        self.width=width
+        #to make starting v random do someting about making vx and vy random
+        self.vx=random.choice([-1,-.8,-.6,-.4,-.2,.2,.4,.6,.8,1])
+        self.vy=random.choice([-1,-.8,-.6,-.4,-.2,.2,.4,.6,.8,1])
+        self.rect = pygame.Rect(self.x, self.y, self.height, self.width)
+    def update(self):
+        """ update the state of the puck """
+        if self.y>=480 or self.y<=0:
+            self.vy=-self.vy
+        if self.x>640 or self.x<=0:
+            self.vx= -self.vx
+        self.x += self.vx
+        self.y+=self.vy
+    def draw(self, surface):
+        self.screen = pygame.display.set_mode(size)
+        self.screen.fill(pygame.Color(0,0,0))
+        pygame.draw.rect(screen, (55,150,55), self.rect)
+        self.x = self.rect.left
+        self.y = self.rect.top
+    def __str__(self):
+        return "Puck x coordinate=%f, y coordinate=%f, radius=%f, width=%f" % (self.x,
+                                                        self.y,
+                                                           self.height,
+                                                          self.w)
+
+class PyGameKeyboardController(object):
+    """ Handles keyboard input for brick breaker """
+    def __init__(self,model):
+        self.model = model
+
+    def handle_event(self,event):
+        """ arrow keys + WS modify the y position of the paddles"""
+        pressed = pygame.key.get_pressed()
+        if pressed[pygame.K_UP]:
+             self.model.paddle2.vy = -1
+        elif pressed[pygame.K_DOWN]:
+             self.model.paddle2.vy = 1
+        else:
+            self.model.paddle2.vy = 0
+        if pressed[pygame.K_w]:
+             self.model.paddle.vy = -1
+        elif pressed[pygame.K_s]:
+             self.model.paddle.vy = 1
+        else:
+            self.model.paddle.vy = 0
+
+if __name__ == '__main__':
+    pygame.init()
+
+    size = (640, 480)
+
+    model = Model(size)
+    print(model)
+    view = PyGameWindowView(model, size)
+    controller = PyGameKeyboardController(model)
+
+    running = True
+    while running:
+        for event in pygame.event.get():
+            if event.type == QUIT:
+                running = False
+        controller.handle_event(event)
+        screen = pygame.display.set_mode(size)
+        screen.fill((0, 0, 0))
+        model.update()
+        view.draw()
+        time.sleep(.001)
+time.sleep(.001)
+
+pygame.quit()