updates

entity.py

@@ -0,0 +1,84 @@
+import math
+
+
+class Entity:
+    def __init__(self, pos, vel, radius, health):
+        self._posX, self._posY = pos
+        self._velX, self._velY = vel
+        self._radius = radius
+        self._health = health
+        self._isDead = False
+
+    # Collision check
+    def collidesWith(self, other):
+        deltaX = other.posX - self._posX
+        deltaY = other.posY - self._posY
+        distanceBetweenCenters = math.sqrt(deltaX ** 2 + deltaY ** 2)
+        return distanceBetweenCenters < self._radius + other.radius
+
+    def takeDamage(self, projectile):
+        if self.collidesWith(projectile):
+            self._health -= projectile.damage
+        self._isDead = (self._health <= 0)
+
+    # Change in velocity of self as a result of collision
+    def collisionResultant(self, other):
+        if not self.collidesWith(other):
+            return (0, 0)
+        deltaX = self._posX - other.posX
+        deltaY = self._posY - other.posY
+        # Push back in opposite direction
+        scalar = 100 / math.sqrt(deltaX ** 2 + deltaY ** 2)
+        return (deltaX * scalar, deltaY * scalar)
+
+    # Position of entity center
+    @property
+    def posX(self):
+        return self._posX
+
+    @posX.setter
+    def posX(self, value):
+        self._posX = value
+
+    @property
+    def posY(self):
+        return self._posY
+
+    @posY.setter
+    def posY(self, value):
+        self._posY = value
+
+    # 2-tuple packing of posX and posY
+    @property
+    def pos(self):
+        return (self._posX, self._posY)
+
+    @property
+    def intPos(self):
+        return tuple(map(int, self.pos))
+
+    # Velocity of entity
+    @property
+    def velX(self):
+        return self._velX
+
+    @velX.setter
+    def velX(self, value):
+        self._velX = value
+
+    @property
+    def velY(self):
+        return self._velY
+
+    @velY.setter
+    def velY(self, value):
+        self._velY = value
+
+    # Radius of entity
+    @property
+    def radius(self):
+        return self._radius
+
+    @property
+    def isDead(self):
+        return self._isDead

hostile.py

@@ -0,0 +1,23 @@
+from entity import *
+from item import *
+
+
+class Hostile(Entity):
+	def __init__(self, pos, vel, radius, health, vision, gun):
+		super().__init__(pos, vel, radius, health)
+		self._vision = vision
+		self._gun = gun
+
+	# Check if player is in range
+	def inRange(self, player):
+		# Check distance to player
+		return math.sqrt((self._posX-player.posX)**2+(self._posY-player.posY)**2) <= self._vision
+
+	# Follows player after it comes within range
+	def pursuit(self, player):
+		pass
+
+	@property
+	def gun(self):
+		return self._gun
+

item.py

@@ -0,0 +1,71 @@
+class Item:
+    def __init__(self, name, projRadius, projSpeed, projRange, damage, magSize, totalAmmo, fireRate, lastShot):
+        self._name = name
+        self._projRadius = projRadius
+        self._projSpeed = projSpeed
+        self._projRange = projRange
+        self._damage = damage
+        self._magSize = magSize
+        self._totalAmmo = totalAmmo
+        self._currentMag = magSize
+        self._remainingAmmo = totalAmmo - magSize
+        self._fireRate = fireRate # minimum amount of time between shots (in milliseconds)
+        self._lastShot = lastShot # time of last shot
+
+    def canShoot(self, currentTime):
+        return self._currentMag > 0 and currentTime - self._lastShot >= self._fireRate
+
+    def reload(self):
+        self._remainingAmmo -= self._magSize
+        self._remainingAmmo += self._currentMag
+        self._currentMag = self._magSize
+        if self._remainingAmmo < 0:
+            self._currentMag += self._remainingAmmo
+            self._remainingAmmo = 0
+
+    def depleteAmmo(self):
+        self._currentMag -= 1
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def projRadius(self):
+        return self._projRadius
+
+    @property
+    def projSpeed(self):
+        return self._projSpeed
+
+    @property
+    def projRange(self):
+        return self._projRange
+
+    @property
+    def damage(self):
+        return self._damage
+
+    @property
+    def magSize(self):
+        return self._magSize
+
+    @property
+    def totalAmmo(self):
+        return self._totalAmmo
+
+    @property
+    def currentMag(self):
+        return self._currentMag
+
+    @property
+    def remainingAmmo(self):
+        return self._remainingAmmo
+
+    @property
+    def lastShot(self):
+        return self._lastShot
+
+    @lastShot.setter
+    def lastShot(self, value):
+        self._lastShot = value