Turning in MP4

README.md

@@ -1,3 +1,33 @@
-# InteractiveProgramming
+# Interactive Programming
 
-This is the base repo for the interactive programming project for Software Design at Olin College.
+Software Design MP4 <br />
+Hand-Tracking Fruit Ninja
+
+In this immersive gaming experience, Fruit Ninja moves off of your phone screen and into 3D! Swipe your hand through space and slice the fruit on the screen in real time. The game is infinite, and so is the fun.
+
+## Getting Started:
+
+### Installing Packages
+This game makes use of OpenCV and Pygame libraries. For everything you need, run the following. <br />
+
+pip install cv2, pygame, numpy, imutils, argparse
+
+### Downloading Files
+Download the following files, as well as all fruit images, from the repository: <br />
+
+ninja.py: main game file <br />
+all_fruits.py: holds fruit class and apple, banana, strawberry subclasses <br />
+Scoring.py: holds scoreboard class <br />
+
+### Usage
+To run the game, run ninja.py with Python 3.
+
+### Calibration
+The game requires a still image from the webcam to begin hand detection. A camera display will pop up when you run ninja.py, in which the captured frame is contained within the blue rectangle. Make sure your hand is not in this area! Click on the webcam screen and press "b" on the keyboard when you're ready to take a picture. <br />
+
+When the image has been taken, you're ready to play! Navigate to the game screen and slice the fruit by gesturing. Try to keep the rest of the background as static as possible for the best results (i.e., don't move your computer, have people walking behind you, etc.) <br />
+
+Enjoy!
+
+## Links:
+[Project Reflection](Reflection.pdf)

Scoring.py

@@ -0,0 +1,34 @@
+import random, pygame, sys, pygame.font
+from pygame.locals import *
+
+navyblue = (60,60,100)
+white = (255,255,255)
+
+class Scoreboard(pygame.sprite.Sprite):
+    def __init__(self, screen):
+        pygame.sprite.Sprite.__init__(self)
+        self.fruit_sliced = 0
+        self.fruit_missed = 0
+        self.screen = screen
+
+        self.sb_height, self.sb_width = 50, self.screen.get_width()
+        self.rect = pygame.Rect(0,0, self.sb_width, self.sb_height)
+        self.bg_color = navyblue
+        self.text_color = white
+        self.font = pygame.font.SysFont('Arial', 18)
+
+        self.x_sliced_position, self.y_sliced_position = 20.0, 10.0
+        self.x_missed_position, self.y_missed_position = self.screen.get_width()-100, 10.0
+
+    def prep_scores(self):
+        self.sliced_string = "Sliced: " + str(self.fruit_sliced)
+        self.sliced_image = self.font.render(self.sliced_string, True, self.text_color)
+
+        self.missed_string = "Missed: " + str(self.fruit_missed)
+        self.missed_image = self.font.render(self.missed_string, True, self.text_color)
+
+    def show(self):
+        self.prep_scores()
+        self.screen.fill(self.bg_color, self.rect)
+        self.screen.blit(self.sliced_image, (self.x_sliced_position, self.y_sliced_position))
+        self.screen.blit(self.missed_image, (self.x_missed_position, self.y_missed_position))

all_fruits.py

@@ -0,0 +1,163 @@
+import random, pygame, sys, math
+from pygame.locals import *
+
+white = (255, 255, 255)
+green = (0, 255, 0)
+
+class Fruit(pygame.sprite.Sprite):
+    def __init__(self, screen, image_name):
+        # Call the parent class (Sprite) constructor
+        pygame.sprite.Sprite.__init__(self)
+        self.speed = .3
+        self.screen = screen
+        self.total_time = 0
+        self.time = 0
+
+        self.image =  pygame.image.load(image_name).convert_alpha()
+        self.image.set_colorkey(white)
+        self.image.convert_alpha()
+        self.rect = self.image.get_rect()
+
+        self.x = random.randint(0, self.screen.get_width()-int(self.image.get_width()/2))
+        self.y = self.screen.get_height()+self.image.get_width()
+
+        self.rect.centerx = self.x + (self.image.get_width()/2)
+        self.rect.centery = self.y + (self.image.get_height()/2)
+
+        #figure out direction to fruit to move based on spawn position (left or right)
+        border = screen.get_width()/2
+        #if starts to the left, move over right
+        if (self.x < border):
+            self.direction = 1
+        #if starts over on the right, move left
+        else:
+            self.direction = -1
+
+        #determine realistic trajectory angle that will clear minimum height and not exceed maximum
+        min_height = .6*screen.get_height()
+        max_height = .9*screen.get_height()
+
+        start_distance_from_border = abs(self.x - border)
+        distance_from_border = random.randint(0, int(start_distance_from_border))
+
+        try:
+            min_angle = math.atan(min_height/distance_from_border)
+            max_angle = math.atan(max_height/distance_from_border)
+
+            self.angle = random.randint(int(min_angle), int(max_angle))
+        except:
+            self.angle = math.pi/2
+
+    def move(self, x, y):
+        self.x = x
+        self.y = y
+        self.rect.centerx = x + (self.image.get_width()/2)
+        self.rect.centery = y + (self.image.get_height()/2)
+
+    def toss(self, time_passed):
+        #self.y -= self.speed*time_passed
+        self.total_time = self.total_time+time_passed
+        self.time = self.total_time/800
+
+        x_speed = random.randint(0,25)
+        add_x = math.sin(self.time) * x_speed
+        self.x += self.direction*add_x
+
+        y_speed = random.randint(30,43)
+        add_y = math.cos(self.time) *y_speed
+        self.y -= add_y
+
+    def draw(self):
+        self.screen.blit(self.image, (self.x, self.y))
+
+    def checkCollision(self, other):
+        # returns True or False if apple has collided with other object
+        col = pygame.sprite.collide_rect(self, other)
+        return col
+
+    def fall(self, time_passed):
+        add_x = .15*time_passed
+        self.x += self.direction*add_x
+
+        add_y = .7*time_passed
+        self.y += add_y
+
+class Apple(Fruit):
+    def __init__(self, screen):
+        # Call the parent class (Fruit) constructor
+        super().__init__(screen, 'apple.png')
+
+class Banana(Fruit):
+    def __init__(self, screen):
+        # Call the parent class (Fruit) constructor
+        super().__init__(screen, 'banana.png')
+
+class Strawberry(Fruit):
+    def __init__(self, screen):
+        # Call the parent class (Fruit) constructor
+        super().__init__(screen, 'strawberry.png')
+
+class Half_Apple1(Fruit):
+    def __init__(self, screen, start_x, start_y):
+        # Call the parent class (Fruit) constructor
+        super().__init__(screen, 'apple_half1.png')
+        self.x = start_x
+        self.y = start_y
+
+class Half_Apple2(Fruit):
+    def __init__(self, screen, start_x, start_y):
+        # Call the parent class (Fruit) constructor
+        super().__init__(screen, 'apple_half2.png')
+        self.x = start_x
+        self.y = start_y
+
+class Half_Banana1(Fruit):
+    def __init__(self, screen, start_x, start_y):
+        # Call the parent class (Fruit) constructor
+        super().__init__(screen, 'ban2.png')
+        self.x = start_x
+        self.y = start_y
+
+class Half_Banana2(Fruit):
+    def __init__(self, screen, start_x, start_y):
+        # Call the parent class (Fruit) constructor
+        super().__init__(screen, 'ban1.png')
+        self.x = start_x
+        self.y = start_y
+
+class Half_Strawberry1(Fruit):
+    def __init__(self, screen, start_x, start_y):
+        # Call the parent class (Fruit) constructor
+        super().__init__(screen, 'straw1.png')
+        self.x = start_x
+        self.y = start_y
+
+class Half_Strawberry2(Fruit):
+    def __init__(self, screen, start_x, start_y):
+        # Call the parent class (Fruit) constructor
+        super().__init__(screen, 'straw2.png')
+        self.x = start_x
+        self.y = start_y
+
+class Sword(pygame.sprite.Sprite):
+    def __init__(self, x, y, screen):
+        # Call the parent class (Sprite) constructor
+        pygame.sprite.Sprite.__init__(self)
+        self.x = x
+        self.y = y
+        self.screen = screen
+
+        self.image =  pygame.image.load("sword.png")
+        self.rect = self.image.get_rect()
+
+    def move(self, x, y):
+        self.x = x
+        self.y = y
+        self.rect.centerx = x
+        self.rect.centery = y
+
+    def draw(self):
+        self.screen.blit(self.image, self.rect)
+
+    def printrect(self):
+        print(self.rect.centerx, ", ", self.rect.centery)