Add files via upload

Author: Luis Lpz

Assets/hit.wav

@@ -0,0 +1,16 @@
+
+class Circle:
+
+    def __init__(self, center, radius):
+
+        self.center = center
+        self.radius = radius
+
+    # takes in another circle
+    def overlaps(self, other):
+
+        distance = (self.center - other.center).magnitude()
+
+        sum_radii = self.radius + other.radius
+
+        return distance <= sum_radii

Assets/laser_shot.wav

@@ -0,0 +1,224 @@
+
+from pygame import draw
+from Vector2 import Vector2
+from Circle import Circle
+import random
+import math
+import weakref
+
+
+# This class describes game objects in our game
+class Entity(object):
+
+    def __init__(self):
+
+        # R G B
+        # default color is white
+        self.color = (255, 255, 255)
+
+        self.graphicsBounds = Circle(Vector2(0.0, 0.0), 1)
+
+        self.collider = Circle(Vector2(0.0, 0.0), 1)
+
+        self.position = Vector2(0.0, 0.0)
+        self.velocity = Vector2(0.0, 0.0)
+
+        self.acceleration = Vector2(0.0, 0.0)
+
+        self.max_speed = 400
+
+    def update(self, dt):
+
+        self.velocity += self.acceleration * dt
+        self.position += self.velocity * dt
+
+        # cap speed
+        if self.velocity.magnitude() >= self.max_speed:
+            self.velocity.set_magnitude(self.max_speed)
+
+        # Update graphical and physical bounds
+        self.graphicsBounds.center = self.position
+        self.collider.center = self.position
+
+    def render(self, screen):
+
+        center = self.graphicsBounds.center
+        radius = self.graphicsBounds.radius
+
+        # Pygame needs a 2-tuple of integers as the center of a circle
+        center_int = (int(center.x), int(center.y))
+
+        draw.circle(screen, self.color, center_int, radius)
+
+
+class Bullet(Entity):
+
+    def __init__(self, range, position, velocity):
+
+        # Construct parent so we have all of the Entities properties
+        # like position, velocity...
+        super(Bullet, self).__init__()
+
+        # How far the bullet travels
+        self.range = range
+
+        self.position = Vector2(position.x, position.y)
+        self.velocity = Vector2(velocity.x, velocity.y)
+
+        # The time needed to travel a certain range
+        self.life = range / self.velocity.magnitude()
+
+    def update(self, dt):
+
+        # Call parent update so we can still move
+        super(Bullet, self).update(dt)
+
+        # Kill the bullet slowly
+        self.life -= dt
+
+
+class Asteroid(Entity):
+
+    def __init__(self, target, homing_speed):
+
+        super(Asteroid, self).__init__()
+
+        self.target = weakref.ref(target)
+
+        self.homing_speed = homing_speed
+
+    def update(self, dt):
+
+        super(Asteroid, self).update(dt)
+
+        self.follow()
+
+    def follow(self):
+
+        if self.target() is None:
+            return
+
+        to_target = Vector2.get_normal(self.target().position - self.position)
+
+        self.acceleration = to_target * self.homing_speed
+
+
+class Particle(Entity):
+
+    def __init__(self, life, position, velocity):
+
+        super(Particle, self).__init__()
+
+        self.life = life
+        self.position = Vector2(position.x, position.y)
+        self.velocity = Vector2(velocity.x, velocity.y)
+
+        self.active = False
+
+    def update(self, dt):
+
+        if not self.active:
+            return
+
+        super(Particle, self).update(dt)
+
+        self.life -= dt
+
+        if self.life <= 0:
+            self.active = False
+
+    def render(self, screen):
+
+        if self.active:
+            super(Particle, self).render(screen)
+
+
+class BurstEmitter(Entity):
+
+    def __init__(self, particle_count, max_life):
+
+        self.particles = list()
+
+        for i in xrange(0, particle_count):
+            self.particles.append(Particle(1, Vector2(0, 0), Vector2(0, 0)))
+
+        self.life = max_life
+
+    def update(self, dt):
+
+        for p in self.particles:
+            p.update(dt)
+
+        self.life -= dt
+
+    def render(self, screen):
+
+        for p in self.particles:
+            p.render(screen)
+
+    def emit(self, position):
+
+        for p in self.particles:
+
+            p.active = True
+
+            p.position = Vector2(position.x, position.y)
+
+            p.velocity = Vector2(1, 0)
+            p.velocity.set_direction(random.uniform(0, 2 * math.pi))
+            p.velocity.set_magnitude(random.randint(200, 500))
+
+            size = random.randint(2, 8)
+            p.graphicsBounds.radius = size
+
+            p.life = random.uniform(0.2, 2.5)
+
+            p.color = (0, 255, 0)
+
+    def is_done(self):
+        return self.life <= 0
+        
+class BurstEmitter2(Entity):
+
+    def __init__(self, particle_count, max_life):
+
+        self.particles = list()
+
+        for i in xrange(0, particle_count):
+            self.particles.append(Particle(1, Vector2(0, 0), Vector2(0, 0)))
+
+        self.life = max_life
+
+    def update(self, dt):
+
+        for p in self.particles:
+            p.update(dt)
+
+        self.life -= dt
+
+    def render(self, screen):
+
+        for p in self.particles:
+            p.render(screen)
+
+    def emit(self, position):
+
+        for p in self.particles:
+
+            p.active = True
+
+            p.position = Vector2(position.x, position.y)
+
+            p.velocity = Vector2(1, 0)
+            p.velocity.set_direction(random.uniform(0, 1 * math.pi))
+            p.velocity.set_magnitude(random.randint(50, 100))
+
+            size = random.randint(2, 8)
+            p.graphicsBounds.radius = size
+
+            p.life = random.uniform(0.2, 2.5)
+
+            p.color = (0, 255, 255)
+
+    def is_done(self):
+        return self.life <= 0

Assets/song.mp3

@@ -1,2 +1,2 @@
-# LovelacesAsteroids
-Team lovelace asteroid modification
+# HomingAsteroids
+Tutorial game for ACM game dev

Circle.py

@@ -0,0 +1,129 @@
+
+from math import sqrt
+from math import acos
+from math import sin
+from math import cos
+
+
+__author__ = 'unit978'
+
+
+# Two dimensional vector that supports the basic operations
+# such addition of vectors, scalar multiplication, dot product,
+# and normalization
+class Vector2:
+
+    def __init__(self, x=0.0, y=0.0):
+        self.x = x
+        self.y = y
+
+    def __add__(self, other):
+        return Vector2(self.x + other.x, self.y + other.y)
+
+    def __iadd__(self, other):
+        self.x += other.x
+        self.y += other.y
+        return self
+
+    def __sub__(self, other):
+        return Vector2(self.x - other.x, self.y - other.y)
+
+    def __isub__(self, other):
+        self.x -= other.x
+        self.y -= other.y
+        return self
+
+    def __mul__(self, scale):
+        return Vector2(self.x * scale, self.y * scale)
+
+    def __rmul__(self, scale):
+        return self.__mul__(scale)
+
+    def __div__(self, scale):
+        return self.__mul__(1/scale)
+
+    def scale_by(self, s):
+        self.x *= s
+        self.y *= s
+
+    # Return copy of a scaled version of the vector
+    @staticmethod
+    def get_scaled_by(vector2, s):
+        return Vector2(vector2.x*s, vector2.y*s)
+
+    def normalize(self):
+        m = self.magnitude()
+
+        if m == 0:
+            self.x = 0
+            self.y = 0
+
+        else:
+            self.x /= m
+            self.y /= m
+
+    # Return a copy of the normalized vector
+    @staticmethod
+    def get_normal(vector2):
+        v = Vector2(vector2.x, vector2.y)
+        v.normalize()
+
+        return v
+
+    def magnitude(self):
+        return sqrt(self.x*self.x + self.y*self.y)
+
+    # Squared magnitude
+    def sq_magnitude(self):
+        return self.x*self.x + self.y*self.y
+
+    def set_magnitude(self, mag):
+        # Use properties of similar triangles
+        m = self.magnitude()
+        if m != 0:
+            ratio = mag / m
+            self.x *= ratio
+            self.y *= ratio
+        else:
+            self.x = 0.0
+            self.y = 0.0
+
+    # Uses the angle between i-unit vector and x-y vector component
+    def direction(self):
+        r = acos(self.x / self.magnitude())
+        if self.y < 0:
+            r *= -1
+        return r
+
+    # direction must be in radians
+    def set_direction(self, direction):
+        m = self.magnitude()
+        self.x = m * cos(direction)
+        self.y = m * sin(direction)
+
+        # y_temp = m * sin(direction)
+        # self.y = -y_temp if self.y > 0 else y_temp
+
+    # Dot product of two vectors
+    def dot(self, other):
+        return self.x*other.x + self.y*other.y
+
+    # Return angle between vectors a and b
+    @staticmethod
+    def angle(vector_a, vector_b):
+        n = vector_a.dot(vector_b)
+        d = vector_a.magnitude() * vector_b.magnitude()
+        return acos(n / d)
+
+    def zero(self):
+        self.x = 0
+        self.y = 0
+
+    def is_zero(self):
+        return self.x == 0 and self.y == 0
+
+    def __str__(self):
+        return "<" + str(self.x) + ", " + str(self.y) + ">"
+
+    def to_tuple(self):
+        return self.x, self.y