entity.py

import pygame
import math2d
import random
import BigDict
import copy
import world

class Entity(object):
    """ A Generic thing that is draw on the screen.
        Some common things:
            1. Sprite
            2. Position
            3. Size
        We will create derived classes from this for:
            Players
            Enemies
            Loot
            Pressure Plates
            ...
    """
    def __init__(self, pos, spriteName, spriteDBase):
        self.state = 0      # When 0, alive. When 1, dying. When 2, it is dead, and needs to be removed
        self.spriteDB = spriteDBase  # Needed for creating projectiles
        self.sprite = spriteDBase.get(spriteName)
        if not isinstance(pos, math2d.Vector2):     # Making sure the position of this Entity is a Vector2 object
            self.pos = math2d.Vector2(pos[0], pos[1])   # WORLD position of the bottom-middle of the character (feet when standing)
        else:
            self.pos = pos
        self.size = 20      # Radius of the bounding circle (centered at self.pos) used for wall / trap hit-detection
                            #       Normal size of (nearly) all entities is set here
        self.hitRadius = 5  # The radius of the circle used for weapons
        self.damageScale = 25   # Multiplied by the weapon damage factor
                            #    ^^^ These two are placed here to be used for projectiles and the Player

    def render(self, surf, cameraPos):
        """ Draw a blobby shadow underneath the character """
        # We might need to replace this with a "shadow" image; the corners
        #     of the rectangular surface appear around the circle as-is
        tempS = pygame.Surface((self.size * 2, self.size * 2))   # Create an off-screen, semi-transparent (soon) surface
        tempS.fill((255,255,255))                                # Temporary?
        tempS.set_alpha(64)                                      # Arbitrary number for transparency; lower numbers = more transparent
        tempS.set_colorkey((255,255,255))

        pygame.draw.circle(tempS, (0,0,0), (self.size, self.size), self.size)       # Draws the shadow
        surf.blit(tempS, (self.pos[0] - cameraPos[0] - self.size, self.pos[1] - cameraPos[1] - self.size))   # Blit the shadow to the screen at self.pos

    def update(self, dT):
        """ Do any pertinent updates """
        pass

class Projectile(Entity):
    """ A class for projectiles. Whenever a projectile is fired, create
        a projectile object. """
    def __init__(self, pos, spriteName, spriteDBase, firingWeapon, direction, shooter, atkType):
        Entity.__init__(self, pos, spriteName, spriteDBase)
        # NOTE: The position of the projectile is the point used for hit detection (the middle, front edge based on direction)
        self.range = firingWeapon[6]
        self.distTravelled = 0          # The amount of distance the projectile has already travelled
        self.speed = 500 * firingWeapon[7]
        if atkType == "Normal":
            self.damage = firingWeapon[4]
        elif atkType == "Power":
            self.damage = firingWeapon[5]
        self.direction = direction      # W = 0, E = 1...
        self.shooter = shooter          # The object that fired this projectile - so the projectile doesn't hit the one that shot it
        self.firingWeapon = firingWeapon[0]
        self.drawOffset = math2d.Vector2(0, 0)

        # self.drawOffset is the distance from self.pos to the top left corner of the sprite
        if self.direction == 0 and self.firingWeapon == "Bow":
            # Already facing correct direction; no rotation needed
            self.drawOffset = math2d.Vector2(0, self.sprite.get_height() // 2)

        elif self.direction == 1 and self.firingWeapon == "Bow":
            self.sprite = pygame.transform.rotate(self.sprite, 180)
            self.drawOffset = math2d.Vector2(self.sprite.get_width(), self.sprite.get_height() // 2)

        elif self.direction == 2 and self.firingWeapon == "Bow":
            self.sprite = pygame.transform.rotate(self.sprite, -90)
            self.drawOffset = math2d.Vector2(self.sprite.get_width() // 2, 0)

        elif self.direction == 3 and self.firingWeapon == "Bow":
            self.sprite = pygame.transform.rotate(self.sprite, 90)
            self.drawOffset = math2d.Vector2(self.sprite.get_width() // 2, self.sprite.get_height())

        elif self.firingWeapon == "MagicStaff":
            self.drawOffset = math2d.Vector2(32, 32)

    def render(self, surf, cameraPos):
        surf.blit(self.sprite, (int(self.pos[0] - self.drawOffset[0] - cameraPos[0]), int(self.pos[1] - self.drawOffset[1] - cameraPos[1])))
        ####### TEMPORARY #######
##        pygame.draw.circle(surf, (255,0,0), (int(self.pos[0] - cameraPos[0]), int(self.pos[1] - cameraPos[1])), self.hitRadius)

    def update(self, dT, checkList, world):
        """ Updates the projectile. Performs the following:
                1: Move the projectile in the correct direction
                2: Determine how far the projectile has travelled
                    - If it has travelled the maximum range, change its state to 2 (dead)
                3: Check to see if the projectile hits anything """
        displacement = self.speed * dT      # This is the amount of distance the projectile has moved

        ####### Move the projectile #######
        if self.direction == 0:             # West
            self.pos[0] -= displacement
        elif self.direction == 1:           # East
            self.pos[0] += displacement
        elif self.direction == 2:           # North
            self.pos[1] -= displacement
        elif self.direction == 3:           # South
            self.pos[1] += displacement

        self.distTravelled += displacement  # Add to the total distance travelled by the projectile
        if self.distTravelled >= self.range: # The projectile has moved its maximum range
            self.state = 2
        # If this gets code stomped again, someone dies
        if not (world.isSpotWalkable((self.pos[0]), (self.pos[1]))):
            self.state = 2

        for obj in checkList:
            # Does the actual hit detection for this projectile
            if obj == self.shooter:  # Don't hit yourself
                continue
            if isinstance(obj, Player) or isinstance(obj, Enemy):
                # Calculates the distance (scalar) between the hit point and the object
                distance = math2d.Vector2(obj.pos[0] - self.pos[0], obj.pos[1] - self.pos[1] - 10)
                distance = distance.length()

                if distance < obj.size + self.hitRadius:        # If the object is hit, handle the hit (below)
                    if isinstance(obj, Player):
                        obj.lastHitByPlayer = True
                    obj.health -= self.damage * self.damageScale
                    self.state = 2

class Mover(Entity):
    """ A generic class of any entity that moves.
        Some common things:
            1. Has the ability to move
            2. Has a health attribute
            3. Able to perform actions (such as attack)
            4. Able to trigger (most/all) traps
        We will create derived classes from this for:
            1. Player
            2. Enemy
    """
    def __init__(self, pos, spriteName, spriteDBase):
        Entity.__init__(self, pos, spriteName, spriteDBase)
        self.name = spriteName
        self.speed = 200             # The speed of the Mover, in pixels per second - normal speed is set here
        self.tempSpeed = self.speed  # If the speed of the object changes, this changes - NOT self.speed
        self.health = 100.0          # The health this object has - Will be changed later to reflect what class the player is (maybe?)
        self.maxHealth = 100         # The maximum health this object can have
        self.curAction = 0           # Walk, BeingHit, Falling, Idle, Dying
        self.drawDirection = 0       # W, E, N, S
        self.curFrame = 0
        self.animDelay = 0.15        # The amount of time an object is in the same frame until it changes
        self.frameTime = 0.0         # The amount of time this object has been in the same frame
        self.projList = []           # A list of projectiles fired by this Mover
        self.lastHitByPlayer = False # Though only used for the player, the entire Mover update method would have to be copied if
                                     #     this was ONLY in the Player class. This is why there is an isinstance check in update
    def changeAction(self, newAction):
        if self.state == 0:
            self.curAction = newAction
            if (newAction != 0):         # Makes sure it's not walking, so it doesn't reset the animation
                self.curFrame = 0        # As the action changes, the new action
                                         #    starts from the first frame
    def changeDrawDirection(self, newDir):
        """ Directions are as follows:
            W = 0
            E = 1
            N = 2
            S = 3 """
        if self.state == 0:
            if newDir != self.drawDirection:
                self.drawDirection = newDir

            if (self.curAction != 0):
                self.curFrame = 0        # As the direction changes, the action
                                         #    starts from the first frame
    def update(self, dT, checkList, world):
        """ Modify curFrame (every self.animDelay seconds), wrapping around to
         0 if we're at the end of the animation (use self.curAction) """
        if self.health <= 0:
            self.health = 0              # To stop health from going negative if strange things happen
            if self.state == 0:
                self.death()

        if self.health > self.maxHealth:
            self.health = self.maxHealth # Your health cannot exceed its maximum

        self.frameTime += dT             # Increment self.frameTime based on the time that has passed

        for proj in self.projList:
            if proj.state == 2:          # The projectile is dead and needs to be removed
                self.projList.remove(proj)
                continue                 # Don't try to update the projectile afer it's been removed
            proj.update(dT, checkList, world)

        if self.frameTime >= self.animDelay:
            self.curFrame += 1
            self.frameTime = 0           # Reset self.frameTime if the frame changes
            if self.curFrame >= 4:
                self.curFrame = 0
                self.frameTime = 0       # Reset self.frameTime if the frame changes
                if self.state == 1:      # If the object has gone through the "Dying" animation...
                    if not self.lastHitByPlayer and isinstance(self, Player):
                        self.respawn(world)
                    else:
                        self.state = 2   # ... change its state to "Dead"

        self.tempSpeed = self.speed      # If tempSpeed is changed, set it back to the original speed

    def death(self):
        """ Handles the death of the mover. Changes self.curAction to 4 (dying) and self.state to 1.
            Update changes the state of the object to 2 when it's done dying """
        if isinstance(self, Player):
            if self.weapon[0] == "Sword":
                self.appPtr.sounds["exploding head"].play()
            else:
                self.appPtr.sounds["death"].play()
        self.curAction = 4    # The "Dying" action
        self.state = 1        # State is now "Dying"
        self.curFrame = 0
        self.frameTime = 0

    def fall(self):
        """ Handles the death of the mover, IF they have fallen into a pit. """
        self.curAction = 2    # The "Falling" action
        self.state = 1
        self.curFrame = 0
        self.frameTime = 0

    def render(self, surf, cameraPos):
        """ Draw the blobby shadow (from Entity.render), then draw the current
            sprite on top of it. Also, draws a green health bar above the current sprite
            whose width is dependent on self.health. """
        # Draws the shadow by using the render method of the Entity base class
        Entity.render(self, surf, cameraPos)
        # Draws the correct sprite on top of the shadow; for the rect argument,
        #   the first argument is the current column, the second argument is the
        #   currentAction (which determines which group of 4 rows to use) and which
        #   direction (which determines which of the 4 rows to use). Each sprite is 64x64
        surf.blit(self.sprite, (self.pos[0] - 32 - cameraPos[0], self.pos[1] - 64 - cameraPos[1]), (self.curFrame * 64,
            self.curAction * 256 + self.drawDirection * 64, 64,64))
        # Render all projectiles associated with this object
        for proj in self.projList:
            proj.render(surf, cameraPos)
        # Health bar
        pygame.draw.rect(surf, (0,0,0), (self.pos[0] - 49 - cameraPos[0], self.pos[1] - 65 - cameraPos[1], 102, 4))
        pygame.draw.rect(surf, (0,255,0), (self.pos[0] - 48 - cameraPos[0], self.pos[1] - 64 - cameraPos[1], self.health, 2))

class Player(Mover):
    """ A player-controlled entity. Able to access Loot. Able to trigger all traps.
        Has a weapon dictionary-attribute that includes:
            Weapon Type
            Range
            Attack Damage
            Power-Attack Type
            Power-Attack Recharge Rate
            Power-Attack Damage
        which will change as the player changes weapons."""
    def __init__(self, pos, spriteName, spriteDBase, app):
        Mover.__init__(self, pos, spriteName, spriteDBase)
        self.is_attacking = False  # True when the ANIMATION for the attack is going (actually checking for hits)
        self.atkCooldown = 1.0     # Determines when the player can attack. 1.0 is ready (percentage)
        self.is_p_atk = False      # True when the ANIMATION for the p atk is going (checking for hits)
        self.paCharge = 1.0        # Determines when the player can use a power attack. 1.0 is fully charged (percentage)
        self.pAttackColor = (0,0,255)
        self.hand_action = 1       # Initially idle; works just like curAction does for rendering the knight, just for the hands
                                   # Additional note: THIS NUMBER DOES NOT DIFFERENTIATE between attacking and otherwise
        self.hand_frameTime = 0.0  # The amount of time the current hand frame has been shown - used with self.animDelay
        self.hand_frame = 0        # The current frame for the hands
        self.walkDmgTimer = 1.0    # When at 1.0, walking on an enemy will cause damage; if less than that, temporary invuln from this kind of dmg
        self.lastHitByPlayer = False # Set to True if the player is hit by another player, until hit by something other than a player (including ALL traps)
        # For self.weapon: Spritename, attackType, Cooldown (seconds), Power Cooldown (seconds), Damage, Power Damage, Range (pixels), Proj. Speed, hitPtList
        self.weapon = BigDict.BigDict["Pickups"]["Weapons"]["Melee"][0]  # Sets self.weapon to the Sword list
        self.weaponSprite = spriteDBase.get(self.weapon[0])
        self.handSprite = spriteDBase.get("hands")
        #Sound attributes
        self.appPtr = app
        self.lavaBool = False

    def onMove(self, dT, horiz, vert, w):#Does this junk even do anything? Lol
        """ horiz and vert are both floats between -1.0 and 1.0.  Change self.pos """
        if self.state == 0:
            if (w.isSpotWalkable((self.pos[0]) + horiz * (self.size + self.tempSpeed * dT), (self.pos[1]))):
                self.pos[0] += horiz * self.tempSpeed * dT
            if (w.isSpotWalkable((self.pos[0]), (self.pos[1]) + vert * (self.size + self.tempSpeed * dT))):
                self.pos[1] += vert * self.tempSpeed * dT
            # Keeping these ^^^ as two separate if statements. Prevents "sticky" walls when pressing more than 1 direction.

    def walkEnemyDmg(self, checkList):
        """ Check against the checkList to see if you are standing on an enemy. If so,
            cause damage to the player and set self.walkDmgTimer to 0.0. This will be incremented
            in the update method back up to 1.0. """
        if self.state == 0:
            if self.walkDmgTimer < 1.0:
                return None      # If the timer is not full, no damage is taken, nothing happens
            for ene in checkList:
                if isinstance(ene, Enemy):
                    distance = (ene.pos - self.pos).length()        # Gets distance between player pos and enemby pos.
                    if distance > ene.size + self.size:             # If the length is greater than both radius combine. No collision
                        continue
                    else:
                        self.lastHitByPlayer = False
                        self.health -= ene.damage                   # Cause damage (Health points take 5.0 damage points)
                        self.appPtr.sounds[random.choice(("hit1", "hit2", "hit3"))].play()
                        self.walkDmgTimer = 0.0                     # Resets self.walkDmgTimer back to 0.0
                        if self.health < 0:                         # Health cannot be negative.
                            self.health = 0
                        return None                                 # Once you within contact of an enemy stop checking.

    def walkLootCheck(self, checkList):
        """ Check to see if the player has walked over any loot. If so, check to see what type of loot,
            and call the correct method from there. """
        if self.state == 0:
            for loot in checkList:
                if isinstance(loot, Loot):

                    distance = (loot.pos - self.pos).length()
                    if distance > loot.size + self.size:
                        continue
                    else:
                        print("Here")
                        loot.state = 2
                        # Type check to see if it is a weapon or a potion
                        if loot.action == "heal":
                            self.appPtr.sounds["health"].play()
                            self.health += loot.value
                        elif loot.action == "changeClass":
                            self.appPtr.sounds["pickup"].play()
                            self.pickUpWeapon(loot)

    def attack(self, checkList):
        """ checkList is the list of objects to test for a hit.
            Check to see if the player hits anything.
            If there is a hit, handle it. """
        if self.state == 0:
            if self.is_p_atk or self.atkCooldown < 1.0:
                return None         # If the player is already attacking or on cooldown, nothing will happen.

            self.is_attacking = True
            self.atkCooldown = 0.0  # Needs to recharge back up to 1 before it can be used again
            self.hand_frame = 0

            if self.weapon[0] == "Sword" or self.weapon[0] == "StrongSword":
                self.swordAttack(checkList)

            elif self.weapon[0] == "Scythe":
                self.scytheAttack(checkList)

            elif self.weapon[0] == "Bow":
                self.bowAttack(checkList)

            elif self.weapon[0] == "MagicStaff":
                self.staffAttack(checkList)

    def playHitSound(self, obj):
            if isinstance(obj, Player):
                self.appPtr.sounds[random.choice(("hit1", "hit2", "hit3"))].play()
                obj.lastHitByPlayer = True
            elif obj.name == "slime" or obj.name == "slime00cas" or obj.name == "slime00des":
                self.appPtr.sounds["slime hit"].play()
            elif obj.name == "Skeleton Archer":
                self.appPtr.sounds["skeleton hit"].play()
            elif obj.name == "ghost":
                self.appPtr.sounds["ghost hit"].play()
            else: #bomb
                self.appPtr.sounds[random.choice(("bomb hit1", "bomb hit2", "bomb hit3"))].play()

    def scytheAttack(self, checkList):
        """ The hit detection if using a SCYTHE. """
        self.appPtr.sounds["Scythe"].play()
        for obj in checkList:
######### HIT DETECTION FOR hitPtFar! ############
            if obj == self:    # Don't check hits against yourself
                continue
            if isinstance(obj, Player) or isinstance(obj, Enemy):
                # Calculates the distance (scalar) between the hit point and the object
                distance = math2d.Vector2(obj.pos[0] - self.hitPtFar[0], obj.pos[1] - self.hitPtFar[1] - 10)
                distance = distance.length()

                if distance < obj.size + self.hitRadius:        # If the object is hit, handle the hit (below)
                    if isinstance(obj, Player):
                        obj.lastHitByPlayer = True
                    self.playHitSound(obj)
                    obj.health -= self.weapon[4] * self.damageScale // 2

        for obj in checkList:
######### HIT DETECTION FOR hitPtNear! ###########
            if obj == self:    # Don't check hits against yourself
                continue
            if isinstance(obj, Player) or isinstance(obj, Enemy):
                # Calculates the distance (scalar) between the hit point and the object
                distance = math2d.Vector2(obj.pos[0] - self.hitPtNear[0], obj.pos[1] - self.hitPtNear[1] - 10)
                distance = distance.length()

                if distance < obj.size + self.hitRadius:        # If the object is hit, handle the hit (below)
                    if isinstance(obj, Player):
                        obj.lastHitByPlayer = True
                    self.playHitSound(obj)
                    obj.health -= self.weapon[4] * self.damageScale // 2

    def swordAttack(self, checkList):
        """ The hit detection if using a SWORD. """
        self.appPtr.sounds["sword"].play()
        for obj in checkList:
######### HIT DETECTION FOR hitPtFar! ############
            if obj == self:    # Don't check hits against yourself
                continue
            if isinstance(obj, Player) or isinstance(obj, Enemy):
                # Calculates the distance (scalar) between the hit point and the object
                distance = math2d.Vector2(obj.pos[0] - self.hitPtFar[0], obj.pos[1] - self.hitPtFar[1] - 10)
                distance = distance.length()

                if distance < obj.size + self.hitRadius:        # If the object is hit, handle the hit (below)
                    if isinstance(obj, Player):
                        obj.lastHitByPlayer = True
                    self.playHitSound(obj)
                    obj.health -= self.weapon[4] * self.damageScale // 2  # Only the tip of the sword has hit; the full damage is applied if both points hit the target

        for obj in checkList:
######### HIT DETECTION FOR hitPtNear! ###########
            if obj == self:    # Don't check hits against yourself
                continue
            if isinstance(obj, Player) or isinstance(obj, Enemy):
                # Calculates the distance (scalar) between the hit point and the object
                distance = math2d.Vector2(obj.pos[0] - self.hitPtNear[0], obj.pos[1] - self.hitPtNear[1] - 10)
                distance = distance.length()

                if distance < obj.size + self.hitRadius:        # If the object is hit, handle the hit (below)
                    if isinstance(obj, Player):
                        obj.lastHitByPlayer = True
                    self.playHitSound(obj)
                    obj.health -= self.weapon[4] * self.damageScale // 2  # Only the middle of the sword has hit; the full damage is applied if both points hit the target

    def bowAttack(self, checkList):
        """ Hit detection for the BOW. Creates a projectile that handles all hit detection """
        ####### Finding the position of the new projectile #######
        if self.drawDirection == 0:
            projPos = math2d.Vector2(self.pos[0] - 64, self.pos[1] - 20)
        elif self.drawDirection == 1:
            projPos = math2d.Vector2(self.pos[0] + 64, self.pos[1] - 20)
        elif self.drawDirection == 2:
            projPos = math2d.Vector2(self.pos[0], self.pos[1] - 64)
        elif self.drawDirection == 3:
            projPos = math2d.Vector2(self.pos[0], self.pos[1] + 64)

        self.appPtr.sounds["arrow"].play()
        newProjectile = Projectile(projPos, "arrow", self.spriteDB, self.weapon, self.drawDirection, self, "Normal")
        self.projList.append(newProjectile)

    def staffAttack(self, checkList):
        """ Hit detection for the STAFF. Creates a projectile that handles all hit detection """
        ####### Finding the position of the new projectile #######
        self.appPtr.sounds["staff"].play()
        if self.drawDirection == 0:
            projPos = math2d.Vector2(self.pos[0] - 64, self.pos[1] - 20)
        elif self.drawDirection == 1:
            projPos = math2d.Vector2(self.pos[0] + 64, self.pos[1] - 20)
        elif self.drawDirection == 2:
            projPos = math2d.Vector2(self.pos[0], self.pos[1] - 64)
        elif self.drawDirection == 3:
            projPos = math2d.Vector2(self.pos[0], self.pos[1] + 64)

        newProjectile = Projectile(projPos, "Blue projectile", self.spriteDB, self.weapon, self.drawDirection, self, "Normal")
        self.projList.append(newProjectile)

    def swordP_Attack(self, checkList):
        for obj in checkList:
            if obj == self:    # Don't check hits against yourself
                continue
            if isinstance(obj, Player) or isinstance(obj, Enemy):

                if self.drawDirection == 0:         # Facing West
                    if obj.pos[0] > self.pos[0]:    # If the object is to your right, skip it
                        continue
                elif self.drawDirection == 1:       # Facing East
                    if obj.pos[0] < self.pos[0]:    # If the object is to your left, skip it
                        continue
                elif self.drawDirection == 2:       # Facing North
                    if obj.pos[1] > self.pos[1]:    # If the object is below you, skip it
                        continue
                elif self.drawDirection == 3:       # Facing South
                    if obj.pos[1] < self.pos[1]:    # If the object is above you, skip it
                        continue

                # Calculates the distance (scalar) between the hit point and the object
                distance = math2d.Vector2(obj.pos[0] - self.pos[0], obj.pos[1] - self.pos[1])
                distance = distance.length()

                # 96 is the distance the Scythe reaches (192/2)
                if distance < 96:        # If the object is hit, handle the hit (below)
                    if isinstance(obj, Player):
                        obj.lastHitByPlayer = True
                    self.playHitSound(obj)
                    obj.health -= self.weapon[5] * self.damageScale

    def scytheP_Attack(self, checkList):
        for obj in checkList:
            if obj == self:    # Don't check hits against yourself
                continue
            if isinstance(obj, Player) or isinstance(obj, Enemy):
                # Calculates the distance (scalar) between the hit point and the object
                distance = math2d.Vector2(obj.pos[0] - self.pos[0], obj.pos[1] - self.pos[1])
                distance = distance.length()

                # 96 is the distance the Scythe reaches (192/2)
                if distance < 96:        # If the object is hit, handle the hit (below)
                    if isinstance(obj, Player):
                        obj.lastHitByPlayer = True
                    self.playHitSound(obj)
                    obj.health -= self.weapon[5] * self.damageScale

    def bowP_Attack(self, checkList):
        if self.drawDirection == 0:
            projPos = math2d.Vector2(self.pos[0] - 64, self.pos[1] - 20)
        elif self.drawDirection == 1:
            projPos = math2d.Vector2(self.pos[0] + 64, self.pos[1] - 20)
        elif self.drawDirection == 2:
            projPos = math2d.Vector2(self.pos[0], self.pos[1] - 64)
        elif self.drawDirection == 3:
            projPos = math2d.Vector2(self.pos[0], self.pos[1] + 64)

        newProjectile = Projectile(projPos, "flaming_arrow", self.spriteDB, self.weapon, self.drawDirection, self, "Power")
        self.projList.append(newProjectile)

    def staffP_Attack(self, checkList):
        if self.drawDirection == 0:
            projPos = math2d.Vector2(self.pos[0] - 64, self.pos[1] - 20)
        elif self.drawDirection == 1:
            projPos = math2d.Vector2(self.pos[0] + 64, self.pos[1] - 20)
        elif self.drawDirection == 2:
            projPos = math2d.Vector2(self.pos[0], self.pos[1] - 64)
        elif self.drawDirection == 3:
            projPos = math2d.Vector2(self.pos[0], self.pos[1] + 64)

        newProjectile = Projectile(projPos, "purple projectile", self.spriteDB, self.weapon, self.drawDirection, self, "Power")
        self.projList.append(newProjectile)

    def p_attack(self, checkList = None):
        """ checkList is the list of objects to test for a hit.
            Check to see if the player hits anything.
            If there is a hit, handle it. """
        if self.state == 0:
            if self.is_attacking or self.paCharge < 1.0:
                return None                       # If the player is already attacking or on cooldown, nothing will happen.

            self.paCharge = 0.0                   # Needs to recharge back up to 1 before it can be used again
            self.pAttackColor = (0,0,255)
            self.is_p_atk = True
            self.hand_frame = 0

            if self.weapon[0] == "Sword" or self.weapon[0] == "StrongSword":
                self.appPtr.sounds["sword"].play()
                self.swordP_Attack(checkList)
            elif self.weapon[0] == "Scythe":
                self.appPtr.sounds["Scythe"].play()
                self.scytheP_Attack(checkList)

            elif self.weapon[0] == "Bow":
                self.appPtr.sounds["arrow"].play()
                self.bowP_Attack(checkList)

            elif self.weapon[0] == "MagicStaff":
                self.appPtr.sounds["staff"].play()
                self.staffP_Attack(checkList)

    def pickUpWeapon(self, newWeapon):
        self.weapon = newWeapon.value[1]
        self.weaponSprite = self.spriteDB.get(self.weapon[0])
        if newWeapon.value[0] == "Melee":
            self.name = "Knight"
            self.sprite = self.spriteDB.get("Knight")
        elif newWeapon.value[0] == "Ranged":
            self.name = "Archer"
            self.sprite = self.spriteDB.get("Archer")
        elif newWeapon.value[0] == "Magic":
            self.name = "Mage"
            self.sprite = self.spriteDB.get("Mage")

    def update(self, dT, checkList, w):
        Mover.update(self, dT, checkList, w)

        if self.is_attacking:         # Attacking
            self.hand_action = 0

        elif self.is_p_atk:           # P-attacking
            self.hand_action = 1

        elif self.curAction == 0:     # Walking
            self.hand_action = 0

        elif self.curAction == 3:     # Idle
            self.hand_action = 1

        self.hand_frameTime += dT     # Add to the hand frame timer

        if self.paCharge < 1.0:
            self.paCharge += dT / self.weapon[3]     # Divide dT by the cooldown to increase paCharge by a percentage
        else:
            self.pAttackColor = (255,0,255)          # Not even sure what this is, but I think it's necessary for GUI things

        if self.atkCooldown < 1.0:
            self.atkCooldown += dT / self.weapon[2]  # Divide dT by the cooldown of the attack to increase by percentage

        if self.walkDmgTimer < 1.0:
            self.walkDmgTimer += dT   # Increment the damage timer for walking over enemies

        if self.hand_frameTime >= self.animDelay:
            self.hand_frame += 1      # Change to the next hand frame
            self.hand_frameTime = 0   # Reset the timer to 0
            if self.hand_frame < 4:
                if self.weapon[0] == "Sword" or self.weapon[0] == "StrongSword":
                    self.hitPtFar = math2d.Vector2(self.weapon[8][self.drawDirection][self.hand_frame][0][0] + self.pos[0],
                                                   self.weapon[8][self.drawDirection][self.hand_frame][0][1] + self.pos[1])
                    self.hitPtNear = math2d.Vector2(self.weapon[8][self.drawDirection][self.hand_frame][1][0] + self.pos[0],
                                                    self.weapon[8][self.drawDirection][self.hand_frame][1][1] + self.pos[1])
                if self.weapon[0] == "Scythe":
                    self.hitPtNear = math2d.Vector2(self.weapon[8][self.drawDirection][self.hand_frame][0][0] + self.pos[0],
                                                    self.weapon[8][self.drawDirection][self.hand_frame][0][1] + self.pos[1])
                    self.hitPtFar = math2d.Vector2(self.weapon[8][self.drawDirection][self.hand_frame][1][0] + self.pos[0],
                                                   self.weapon[8][self.drawDirection][self.hand_frame][1][1] + self.pos[1])
            if self.hand_frame >= 4:
                self.hand_frame = 0   # Reset back to the first frame
                self.hand_frameTime = 0
                self.is_attacking = False
                self.is_p_atk = False

        trapCheck = (w.isSpotTrap((self.pos[0]), (self.pos[1])-5))
        if trapCheck != -1 and self.state == 0:
            #Pit
            if trapCheck == 0:
                self.lastHitByPlayer = False
                self.fall()
                self.appPtr.sounds["fall"].play()
            #Spikes
            elif trapCheck == 1:
                if self.walkDmgTimer >= 1:
                    if self.lavaBool == True:
                        self.appPtr.sounds["lava"].stop()
                        self.lavaBool = False
                    self.appPtr.sounds["spike"].play()
                    self.lastHitByPlayer = False
                    self.health -= 10
                    self.appPtr.sounds[random.choice(("hit1", "hit2", "hit3"))].play()
                    self.walkDmgTimer = 0
                    self.speed = 75
            #Lava
            if trapCheck == 2:
                if self.lavaBool == False:
                    self.appPtr.sounds["lava"].play()
                    self.lavaBool = True
                if self.walkDmgTimer >= 1:
                    self.lastHitByPlayer = False
                    self.health -= 20
                    self.appPtr.sounds[random.choice(("hit1", "hit2", "hit3"))].play()
                    self.walkDmgTimer = 0
                    self.speed = 75
        else:
            self.speed = 200
            self.appPtr.sounds["lava"].stop()
            self.lavaBool = False
        for obj in checkList:
            if isinstance(obj, Enemy):
                if obj.AI == "chase":
                    obj.visibles = checkList

    def respawn(self,world):
        spawnPoints = copy.deepcopy(BigDict.BigDict["WorldObjects"]["Spawnpoints"])
        self.state = 0                      # Revert the state of the player to 0 (normal)
        self.health = 100                   # Return the player to full health
        spawnIndex = random.randint(0, len(spawnPoints) - 1)
        self.pos = spawnPoints[spawnIndex]  # Put the player's position at the chosen spawnPoint (randomly picked from possible spawnPoints)
        self.pos = math2d.Vector2(self.pos[0], self.pos[1])   # To make sure position is a vector, not a tuple
        if not world.isSpotWalkable(self.pos[0], self.pos[1], "normal") or world.isSpotTrap(self.pos[0], self.pos[1]-5)!=-1:
            print("Trying respawn again, you got stuck in a wall or trap!")
            self.respawn(world)
        self.weapon = BigDict.BigDict["Pickups"]["Weapons"]["Melee"][0]  # Sets self.weapon to the Sword list
        self.weaponSprite = self.spriteDB.get(self.weapon[0])
        self.sprite = self.spriteDB.get("Human")
        self.name = "Human"

    def render(self, surf, cameraPos):
        if self.drawDirection == 2:                 # If the player is facing up...
            self.render_hand(surf, cameraPos)       # render the hands first
            Mover.render(self, surf, cameraPos)     # ...and the player is on top of the hands

        else:                                       # If the player is facing right/down/left...
            Mover.render(self, surf, cameraPos)     # render the player first
            self.render_hand(surf, cameraPos)       # ...and the hands are on top of the player

    def render_hand(self, surf, cameraPos):
        """ Renders the hands """
        if self.is_attacking or self.is_p_atk:      # If the player is attacking or power attacking, render the weapon

            surf.blit(self.weaponSprite, (self.pos[0] - 96 - cameraPos[0], self.pos[1] - 96 - cameraPos[1]), (self.hand_frame * 192,
                    self.hand_action * 768 + self.drawDirection * 192, 192, 192))
##            try:    # A strange error was occuring; this is to handle that error
##                    # Draw the red dot at the tip of the sword, using the point list
##                if self.weapon[0] == "Sword" or self.weapon[0] == "StrongSword" or self.weapon[0] == "Scythe":
##                    pygame.draw.circle(surf, (255,0,0), (int(self.hitPtFar[0] - cameraPos[0]), int(self.hitPtFar[1] - cameraPos[1])), self.hitRadius)
##                    pygame.draw.circle(surf, (255,0,0), (int(self.hitPtNear[0] - cameraPos[0]), int(self.hitPtNear[1] - cameraPos[1])), self.hitRadius)
##
##            except: # To handle the strange error case where hitPtFar was not defined before this was called
##                pass

        else:
            surf.blit(self.handSprite, (self.pos[0] - 96 - cameraPos[0], self.pos[1] - 96 - cameraPos[1]), (self.hand_frame * 192 + 3,
                self.hand_action * 768 + self.drawDirection * 192 + 3, 192, 192))

class Enemy(Mover):
    """ A NPC entity. Unable to access Loot. Able to trigger [most?] traps. """
    def __init__(self, pos, sprite, spriteDBase):
        Mover.__init__(self, pos, sprite, spriteDBase)
        self.spriteName = sprite
        self.duration = random.randint(1,5)         # Randomly determines how long the enemy will maintain the same action
        self.direction = random.randint(0,4)        # Picks a random direction.
        self.visibles = []

    def randMove(self, dT, w):
        """ Randomly moves the enemy in a direction for a duration, using self.duration and self.direction """
        self.duration -= dT

        if self.direction == 0:     # If moving west: go left.
            if (w.isSpotWalkable((self.pos[0]) - 16 + self.tempSpeed * dT, (self.pos[1]), "enemy") or (self.spriteName == "ghost" and self.pos[0] > 0)):
                self.pos[0] -= self.tempSpeed * dT
                self.changeDrawDirection(0)
        elif self.direction == 1:   # If moving east: go right.
            if (w.isSpotWalkable((self.pos[0]) + 32 + self.tempSpeed * dT, (self.pos[1]), "enemy") or (self.spriteName == "ghost" and self.pos[0] < w.worldWidthT)):
                self.pos[0] += self.tempSpeed * dT
                self.changeDrawDirection(1)
        elif self.direction == 2:   # If moving north: go up.
            if (w.isSpotWalkable((self.pos[0]), (self.pos[1]) - 16 + self.tempSpeed * dT, "enemy") or (self.spriteName == "ghost" and self.pos[1] > 0)):
                self.pos[1] -= self.tempSpeed * dT
                self.changeDrawDirection(2)
        elif self.direction == 3:   # If moving south: go down.
            if (w.isSpotWalkable((self.pos[0]), (self.pos[1]) + 32 + self.tempSpeed * dT, "enemy") or (self.spriteName == "ghost" and self.pos[1] < w.worldHeightT)):
                self.pos[1] += self.tempSpeed * dT
                self.changeDrawDirection(3)

        if self.duration <= 0:      # Changes direction randomly, then randomly chooses new direction and rate.
            self.changeDrawDirection(self.direction)
            self.duration = random.randint(1,5)
            self.direction = random.randint(0,4)

            if self.AI == "range":  # For ranged enemies
                self.rangeFire(dT, w)

    def chaserMove(self, dT, w):
        """ AI pattern for enemies that chase you """
        chaseDist = 800
        for obj in self.visibles:
            if isinstance(obj, Player):
                # Calculating the distance between the Player and the Enemy
                dist = math2d.Vector2(obj.pos[0] - self.pos[0], obj.pos[1] - self.pos[1])
                distLength = dist.length()     # Finding the length of that distance
                # Start chasing the player if the Player is within the chase distance
                if distLength <= chaseDist:
                    direct = dist.normalized()    # Normalizing the distance so that it is a direction only

                    if abs(direct[0]) > abs(direct[1]) and direct[0] < 0:    # Moving more in the x direction; also moving left
                        self.changeDrawDirection(0)
                    elif abs(direct[0]) > abs(direct[1]) and direct[0] > 0:  # Moving more in the x direction; also moving right
                        self.changeDrawDirection(1)
                    elif abs(direct[0]) < abs(direct[1]) and direct[0] < 0:  # Moving more in the y direction; also moving up
                        self.changeDrawDirection(2)
                    elif abs(direct[0]) < abs(direct[1]) and direct[0] > 0:  # Moving more in the y direction; also moving down
                        self.changeDrawDirection(3)

                    # Making sure it doesn't walk through walls
                    #ignoring because GHOSTS ARE HOMING if (w.isSpotWalkable((self.pos[0]) + direct[0] * (self.size + self.tempSpeed * dT), (self.pos[1]))):
                    self.pos[0] += direct[0] * self.tempSpeed * dT
                    #if (w.isSpotWalkable((self.pos[0]), (self.pos[1]) + direct[1] * (self.size + self.tempSpeed * dT))):
                    self.pos[1] += direct[1] * self.tempSpeed * dT

                    break      # After chasing one object, don't chase another
                    # I realize this will cause strange chase patterns if there are multiple players near the object;
                    #    it won't always chase the nearest player with this code. We will implement this if we have time.

    def rangeFire(self, dT, w):
        """AI to fire a projectile in a random direction"""
        if self.drawDirection == 0:
            projPos = math2d.Vector2(self.pos[0] - 64, self.pos[1] - 20)
        elif self.drawDirection == 1:
            projPos = math2d.Vector2(self.pos[0] + 64, self.pos[1] - 20)
        elif self.drawDirection == 2:
            projPos = math2d.Vector2(self.pos[0], self.pos[1] - 64)
        elif self.drawDirection == 3:
            projPos = math2d.Vector2(self.pos[0], self.pos[1] + 64)
        try:
            if projPos:   # Debugging
                newProjectile = Projectile(projPos, "arrow", self.spriteDB, self.weapon, self.drawDirection, self)
                self.projList.append(newProjectile)
        except:
            pass

    def update(self, dT, w, checkList):
        # The Mover.update will be called once enemy sprite sheets are implemented
        # If the format of enemy sprite sheets is different that those of the player,
        #       then there will be a new update for the enemy class.
        Mover.update(self, dT, checkList, w)
        if self.state == 0:
            if self.AI == "random":
                self.randMove(dT, w)
            if self.AI == "chase":
                self.chaserMove(dT, w)
            if self.AI == "range":
                self.randMove(dT, w)

class Loot(Entity):
    """ Any environmental entity that is helpful to the PLAYER.
        Note: Enemies cannot access any loot. """
    def __init__(self, pos, spritename, action, spriteDBase, value=None):
        Entity.__init__(self, pos, spritename, spriteDBase)
        self.action = action  # A string of what the loot DOES (when picked up), either "changeClass" or "heal" for now
        self.value = value    # If it's a potion for example, the amount it heals by

    def render(self, surf, cameraPos):
        """ Draw the blobby shadow (from Entity.render), then draw the current
            sprite on top of it """
        # Draws the shadow by using the render method of the Entity base class
        Entity.render(self, surf, cameraPos)
        # Draws the sprite of this Loot item on top of the shadow
        surf.blit(self.sprite, (self.pos[0] - self.sprite.get_width()/2 - cameraPos[0], self.pos[1] - self.sprite.get_height()/2 - cameraPos[1]))

class Easy(Enemy):
    def __init__(self, pos, spriteName, health, attack, speed, AI, spriteDBase):
        Enemy.__init__(self, pos, spriteName, spriteDBase)
        self.speed = speed      # Each enemy that has a different speed than 100 px/s is specified based upon the enemy
        self.tempSpeed = self.speed
        self.health = health
        self.maxHealth = health # The maximum health - THIS VALUE SHOULD NOT CHANGE ONCE THE ENEMY IS CREATED.
        self.damage = attack    # Is this attack DAMAGE..? - JBrant: I am implementing it as the damage enemies cause when walked on.
        self.AI = AI
        if self.AI == "range":
            self.weapon = BigDict.BigDict["Pickups"]["Weapons"]["Ranged"][0]