caleb-brown/no-cooperation
Archived
1
0
Fork 0
Code Releases 1 Activity
This repository has been archived on 2024-09-03. You can view files and clone it, but cannot push or open issues or pull requests.
85f7f43e60
no-cooperation/entity.py

836 lines
45 KiB
Python
Raw Normal View History

Added game source code and source images
2021-04-08 11:37:41 -04:00
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]
Copy Permalink