836 lines
45 KiB
Python
836 lines
45 KiB
Python
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] |