diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 0000000..4d1e04d
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,4 @@
+{
+    "python.pythonPath": "C:\\Users\\diveb\\.virtualenvs\\Python-OOP-Toy-Up2074oM\\Scripts\\python.exe",
+    "python.linting.enabled": false
+}
\ No newline at end of file
diff --git a/Pipfile b/Pipfile
new file mode 100644
index 0000000..f1d417c
--- /dev/null
+++ b/Pipfile
@@ -0,0 +1,12 @@
+[[source]]
+url = "https://pypi.org/simple"
+verify_ssl = true
+name = "pypi"
+
+[packages]
+pygame = "*"
+
+[dev-packages]
+
+[requires]
+python_version = "3.6"
diff --git a/Pipfile.lock b/Pipfile.lock
new file mode 100644
index 0000000..93085e1
--- /dev/null
+++ b/Pipfile.lock
@@ -0,0 +1,46 @@
+{
+    "_meta": {
+        "hash": {
+            "sha256": "04d5136a2e3e1a7589c6313b58b439879c213afd077d2d6580213f4255dcef7d"
+        },
+        "pipfile-spec": 6,
+        "requires": {
+            "python_version": "3.6"
+        },
+        "sources": [
+            {
+                "name": "pypi",
+                "url": "https://pypi.org/simple",
+                "verify_ssl": true
+            }
+        ]
+    },
+    "default": {
+        "pygame": {
+            "hashes": [
+                "sha256:22d5195a72b9a300cb7e87d7bde1373930a02b1054e95bc431d26a321ae15d07",
+                "sha256:2a8292d0b5a67e0b96d2cae09bbd8252e99daffe95fd88a00166b92fb6497b40",
+                "sha256:2ee479b0120cc82f04f7c41a09d75fc85c9992ed1a26c9527fb2b7b0637e6739",
+                "sha256:4847550da37d3bc702e0201a035de005f184b19e86625a3c70ab1d318317ee91",
+                "sha256:4d4985d0e0e5470c5ef872d65a863f1722d85a136327eb3bb5dcafc2853f2e55",
+                "sha256:5cf670378c8aabdf1bdf283eeec690c93f95dfe8de77c66bc837c91274c8ca49",
+                "sha256:643de45518d11cb7784e3fe77aef43fe3cb7e0d6b495ad4361ade931f16c334b",
+                "sha256:66746c32d21d8193ab066fdf90da96ed993c4818adb13bf4eaa472f306f7f421",
+                "sha256:73c86fdbbfc5ae77d0271fb0964f4a3fc639cc2277ffeb60ee4e981fb0d27640",
+                "sha256:751021819bdc0cbe5cbd51904abb6ff9e9aee5b0e8955af02284d0e77d6c9ec2",
+                "sha256:792f8d1a455d5d1de9c8f2cc051c6dac2b90705afc4cf9fe4933aeb296b0ae3f",
+                "sha256:831c906d4a70aa58f9382e79671525805583b58ac8c895b4c4bd066e8858a1a1",
+                "sha256:834ee27388563f15e6c736aa4850e4cf95609f67056ee73ff646528bb658e79e",
+                "sha256:925e6be8e8c3f1cec016f5a68f369491ae34600e04633759e0e07780ce7bd083",
+                "sha256:96a8f61c729d82576ee3d5cfe3b0b91e7b52a4fbf3d618a3b659347eeb4fd937",
+                "sha256:97615fb075808b4709f6115e3a11a253bfac78614f430bededbc0ac76a5100af",
+                "sha256:c49ece0e4ba71be90ed4bf6a905c35e5c1a95c4c0b0b42eaff74ab69c5793847",
+                "sha256:e8626d4d4e7617ebf103d96a493b9cbe53f9b39cd46ecbff232e33ba4a082530",
+                "sha256:ea7da8dd7fbc12becccf691b4c76fbb381e369e124c30e21f9ed263b6e7e139a"
+            ],
+            "index": "pypi",
+            "version": "==1.9.3"
+        }
+    },
+    "develop": {}
+}
diff --git a/src/ball.py b/src/ball.py
index 20e2792..43f6091 100644
--- a/src/ball.py
+++ b/src/ball.py
@@ -4,6 +4,7 @@
 from pygame import Rect
 
 from block import KineticBlock
+from block import Paddle
 
 class Ball:
     """
@@ -32,9 +33,11 @@ def update(self, **kwargs):
         if self.position.y <= 0 + self.radius: # screen height
             self.position.y = self.radius + 1
             self.velocity.y *= -1
+            sys.exit() #Win Condition
         if self.position.y >= self.bounds[1] - self.radius:
             self.position.y = self.bounds[1] - self.radius - 1
             self.velocity.y *= -1
+            sys.exit() #Lose Condition
 
         self.position += self.velocity
         self.collision_rectangle = self.update_rectangle()
@@ -117,7 +120,6 @@ def collide_with_rectangle(self, object):
         test = left + right + top + bottom
         
         if test == 1:
-            object.touched_by_ball = True
             # the ball has collided with an edge
             # TODO:  # fix sticky edges
             if left or right:
@@ -134,6 +136,8 @@ def collide_with_rectangle(self, object):
                 else:
                     self.position.y = object.position.y + object.rectangle.height/2 + self.radius + 1
 
+            object.touched_by_ball = True
+
         elif test == 4:
             # TODO:  Better error handling
             print('error:  ball inside rectangle')
@@ -150,20 +154,21 @@ def collide_with_rectangle(self, object):
             for corner in corners:
                 relative_vector = self.position - corner
                 if relative_vector.length() <= self.radius:
-                    object.touched_by_ball = True
                     # Create a dummy object to make use of ball to ball collision, because the math is the same
                     # Give it a velocity of the same magnitude as the current ball to cause it to reflect at
                     # the same speed
                     stand_in = Ball(self.bounds, corner, Vector2(0, self.velocity.length()), [0,0,0], 0)
                     self.collide_with_ball(stand_in, relative_vector)
 
+                    object.touched_by_ball = True
+
     def check_collision(self):
         # Warning!:  This is a primitive method of collision detection
         # Consider time complexity when adding more of this type
         index = self.object_list.index(self)
         for object in self.object_list[index+1:]:  # TODO: Check effeciency
             # Balls colliding with blocks
-            if issubclass(type(object), KineticBlock) and object != self:
+            if (issubclass(type(object), Paddle) or issubclass(type(object), KineticBlock)) and object != self:
                 # Do a first round pass for collision (we know object is a KineticBlock)
                 if self.collision_rectangle.colliderect(object.rectangle):
                     self.collide_with_rectangle(object)
diff --git a/src/block.py b/src/block.py
index f7966e2..26c7cf3 100644
--- a/src/block.py
+++ b/src/block.py
@@ -12,8 +12,8 @@ def __init__(self, position, width, height, color):
         # Create a rectangle centered around the x and y
         self.position = position
         self.rectangle = pygame.Rect(
-                                    position.x - (width/2),
-                                    position.y - (height/2),
+                                    self.position.x - (width/2),
+                                    self.position.y - (height/2),
                                     width,
                                     height)
         self.color = color
@@ -29,9 +29,76 @@ def check_collision(self):
     def draw(self, screen, pygame):
         pygame.draw.rect(screen, self.color, self.rectangle)
 
+class Paddle():
+    def __init__(self, bounds, position, width, height, color):
+        # Create a rectangle centered around the x and y
+        self.bounds = bounds
+        self.position = position
+        self.width = width
+        self.height = height
+        self.rectangle = pygame.Rect(
+                                    self.position.x - (self.width/2),
+                                    self.position.y - (self.height/2),
+                                    self.width,
+                                    self.height)
+        self.color = color
+        self.touched_by_ball = False
+
+    def update(self):
+        self.touched_by_ball = False
+        if pygame.key.get_pressed()[pygame.K_LEFT] == True:
+            if self.position.x <= 0 + self.width/2:
+                self.position.x += 1
+            else:
+                self.position.x += -3
+                self.rectangle = pygame.Rect(
+                                        self.position.x - 3 - (self.width/2),
+                                        self.position.y - (self.height/2),
+                                        self.width,
+                                        self.height)
+        
+        if pygame.key.get_pressed()[pygame.K_RIGHT] == True:
+            if self.position.x >= self.bounds[0] - self.width/2:
+                self.position.x += -1
+            else:
+                self.position.x += 3
+                self.rectangle = pygame.Rect(
+                                        self.position.x + 3 - (self.width/2),
+                                        self.position.y - (self.height/2),
+                                        self.width,
+                                        self.height)
+
+    def check_collision(self):
+        pass
+
+    def draw(self, screen, pygame):
+        pygame.draw.rect(screen, self.color, self.rectangle)
+
 class KineticBlock(Block):
     # No custom code needed here, just want to be able to differentiate
     # KineticBall will handle the collison
-    pass
+    def __init__(self, object_list, position, width, height, color):
+        self.object_list = object_list
+        super().__init__(position, width, height, color)
+
+    def update(self):
+        if self.touched_by_ball == True:
+            self.object_list.remove(self)
+
+class StrongKineticBlock(KineticBlock):
+    def __init__(self, object_list, position, width, height, color, strength):
+        self.strength = strength
+        super().__init__(object_list, position, width, height, color)
 
+    def update(self):
+        if self.touched_by_ball == True:
+            if self.strength == 0:
+                self.object_list.remove(self)
+            else:
+                self.strength -= 1
+                self.color[0] = (self.color[0] + 100) % 256
+                self.color[1] = (self.color[1] - 100) % 256
+                self.color[2] = (self.color[2] + 50) % 256
+                self.touched_by_ball = False
 
+        
diff --git a/src/draw.py b/src/draw.py
index 14ff036..46d6902 100644
--- a/src/draw.py
+++ b/src/draw.py
@@ -6,19 +6,41 @@
 from ball import *
 from block import *
 
-SCREEN_SIZE = [640, 480]
-BACKGROUND_COLOR = [255, 255, 255]
+SCREEN_SIZE = [400, 800]
+BACKGROUND_COLOR = [0, 0, 0]
 
 def debug_create_objects(object_list):
     kinetic = GameBall(1, object_list, SCREEN_SIZE, 
-                                    Vector2(random.randint(20, SCREEN_SIZE[0] - 20), random.randint(20, SCREEN_SIZE[1] - 20)),
-                                    Vector2(4*random.random() - 2, 4*random.random() - 2),
-                                    [255, 10, 0], 20)
+                                    Vector2(200 , 700),
+                                    Vector2(2.5 , -2.5),
+                                    [255, 0, 255], 5)
     object_list.append(kinetic)
 
-    block = KineticBlock(Vector2(200,200), 100, 100, [0, 0, 255])
-    object_list.append(block)
-  
+    paddle = Paddle(SCREEN_SIZE, Vector2(200,720), 75, 10, [255, 0, 255])
+    object_list.append(paddle)
+
+    # block array
+    block1 = KineticBlock(object_list, Vector2(35,200), 50, 20, [0, 0, 255])
+    object_list.append(block1)
+
+    block2 = StrongKineticBlock(object_list, Vector2(90,200), 50, 20, [0, 0, 255], 2)
+    object_list.append(block2)
+
+    block3 = KineticBlock(object_list, Vector2(145,200), 50, 20, [0, 0, 255])
+    object_list.append(block3)
+
+    block4 = KineticBlock(object_list, Vector2(200,200), 50, 20, [0, 0, 255])
+    object_list.append(block4)
+
+    block5 = KineticBlock(object_list, Vector2(255,200), 50, 20, [0, 0, 255])
+    object_list.append(block5)
+
+    block6 = KineticBlock(object_list, Vector2(310,200), 50, 20, [0, 0, 255])
+    object_list.append(block6)
+    
+    block7 = KineticBlock(object_list, Vector2(365,200), 50, 20, [0, 0, 255])
+    object_list.append(block7)
+
 def main():
     pygame.init()
     screen = pygame.display.set_mode(SCREEN_SIZE)