218eb2ea7e
added character collisions (not great yet tho) some simple background elements added and testet WIP
249 lines
8.4 KiB
Python
249 lines
8.4 KiB
Python
import pygame as pg
|
|
vec = pg.math.Vector2
|
|
fps = 60
|
|
|
|
|
|
pg.font.init()
|
|
fonts = {
|
|
'medieval': 'medieval.ttf',
|
|
'minecraft': 'Minecraft Evenings.otf',
|
|
'3dpixel': '3D-Pixel.ttf',
|
|
'8bit': '8bitlim.ttf',
|
|
'8bito': '8blimro.ttf',
|
|
'arcade': 'ARCADECLASSIC.ttf',
|
|
'modern_game': 'astron boy video.otf',
|
|
'modern': 'astron boy.otf',
|
|
'wonder': 'Beyond Wonderland.ttf',
|
|
'curved': 'Digitag.ttf',
|
|
'simple': 'DisposableDroidBB.ttf',
|
|
'rounded': 'dpcomic.ttf',
|
|
'playfull': 'Endalian Script.ttf',
|
|
'blocky': 'FREAKSOFNATURE.ttf',
|
|
'catchy': 'Future TimeSplitters.otf',
|
|
'simple_wide': 'Halo3.ttf',
|
|
'simple_fat': 'INVASION2000.ttf',
|
|
'very_gamy': 'ka1.ttf',
|
|
'simple_round': 'Karma Suture.otf',
|
|
'mono': 'manaspc.ttf',
|
|
'damaged': 'Merchant Copy.ttf',
|
|
'big_natural': 'MorialCitadel.TTF',
|
|
'spacy': 'nasalization-rg.otf',
|
|
'sci-fi': 'neuropol.otf',
|
|
'hollow_big_edge': 'papercut.ttf',
|
|
'space_shuttle': 'pdark.ttf',
|
|
'thin': 'PixelFJVerdana12pt.ttf',
|
|
'random': 'Seattle Avenue.ttf',
|
|
'pixel': 'yoster.ttf'
|
|
}
|
|
|
|
class Objects():
|
|
def __init__(self, name, ms, sprite, x, y) -> None:
|
|
self.name = name
|
|
self.speed = ms
|
|
with open(f'art/images/{sprite}') as i:
|
|
self.sprite = pg.image.load(i)
|
|
self.x = x
|
|
self.y = y
|
|
self.hidden = False
|
|
|
|
self.rect = pg.Rect(self.x, self.y, self.sprite.get_width(), self.sprite.get_height())
|
|
|
|
def draw(self, screen):
|
|
if self.hidden:
|
|
return
|
|
self.rect.x, self.rect.y = self.x, self.y
|
|
screen.blit(self.sprite, self.rect)
|
|
|
|
|
|
class NPC(Objects):
|
|
pass
|
|
|
|
|
|
class Fighter(Objects):
|
|
def __init__(self, name, ms, sprite, x, y, health, damage, level, asp, atr) -> None:
|
|
super().__init__(name, ms, sprite, x, y)
|
|
self.health = health
|
|
self.damage = damage
|
|
self.level = level
|
|
self.attack_speed = asp
|
|
self.attack_range = atr
|
|
self.lastHurt = pg.time.get_ticks()
|
|
self.lastAttack = pg.time.get_ticks()
|
|
self.hurtCooldown = 250
|
|
|
|
|
|
|
|
class MainCharacter(Fighter):
|
|
def __init__(self, name, ms, sprite, x, y, health, damage, level, asp, atr, weapon=None, shield=None) -> None:
|
|
super().__init__(name, ms, sprite, x, y, health, damage, level, asp, atr)
|
|
self.attack_spell = weapon
|
|
self.shield_spell = shield
|
|
self.talking = False
|
|
self.level = Level(1000, 38, level, 150, 40, f'will to live: {level}%', 'simple', 20)
|
|
self.health = Hearts(health, sprite=['fullheart.png', 'fullheart.png', 'fullheart.png', 'fullheart.png', 'fullheart.png'], x=900, y= 50)
|
|
|
|
def draw(self, screen):
|
|
if self.hidden:
|
|
return
|
|
self.rect.x, self.rect.y = self.x, self.y
|
|
screen.blit(self.sprite, self.rect)
|
|
self.health.draw(screen)
|
|
self.level.draw(screen)
|
|
|
|
def hurt(self, damage):
|
|
self.health.hurt(damage)
|
|
|
|
def walk(self, keys, objects):
|
|
moveto = vec(0, 0)
|
|
if keys[pg.K_w] or keys[pg.K_UP]:
|
|
moveto += vec(0, -1)
|
|
if keys[pg.K_a] or keys[pg.K_LEFT]:
|
|
moveto += vec(-1, 0)
|
|
if keys[pg.K_s] or keys[pg.K_DOWN]:
|
|
moveto += vec(0, 1)
|
|
if keys[pg.K_d] or keys[pg.K_RIGHT]:
|
|
moveto += vec(1, 0)
|
|
if not moveto == vec(0, 0):
|
|
moveto.scale_to_length(self.speed)
|
|
self.x += moveto[0] / fps
|
|
self.y += moveto[1] / fps
|
|
touches = pg.sprite.spritecollideany(self, objects[1] + objects[2])
|
|
if touches is not None:
|
|
self.x -= moveto[0] / fps #change later
|
|
self.y -= moveto[1] / fps #change later
|
|
|
|
def update(self, keys, objects):
|
|
self.walk(keys, objects)
|
|
if self.health.health <= 0:
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
class Hearts():
|
|
def __init__(self, health, sprite, x, y) -> None:
|
|
self.x = x
|
|
self.y = y
|
|
self.health = health
|
|
self.lastHurt = pg.time.get_ticks()
|
|
self.hurtCooldown = 1000
|
|
self.hidden = False
|
|
self.sprite=[]
|
|
for parts in sprite:
|
|
with open(f'art/images/{parts}') as i:
|
|
self.sprite.append(pg.image.load(i))
|
|
self.rect = []
|
|
for each in self.sprite:
|
|
self.rect.append(pg.Rect(self.x, self.y, each.get_width(), each.get_height()))
|
|
|
|
def hurt(self,damage):
|
|
if self.lastHurt + self.hurtCooldown < pg.time.get_ticks():
|
|
self.health -= damage
|
|
self.lastHurt = pg.time.get_ticks()
|
|
self.update()
|
|
|
|
def draw(self, screen):
|
|
if self.hidden:
|
|
return
|
|
for i in range(0, 5):
|
|
self.rect[i].x, self.rect[i].y = self.x + i * 20, self.y
|
|
screen.blit(self.sprite[i], self.rect[i])
|
|
|
|
def update(self):
|
|
sprite = []
|
|
for i in range(0, 5):
|
|
if self.health >= 4 + 4 * i:
|
|
sprite.append('fullheart.png')
|
|
elif self.health == 3 + 4 * i:
|
|
sprite.append('dreiviertelheart.png')
|
|
elif self.health >= 2 + 4 * i:
|
|
sprite.append('halfheart.png')
|
|
elif self.health >= 1 + 4 * i:
|
|
sprite.append('viertelheart.png')
|
|
elif self.health <= 4 * i:
|
|
sprite.append('noheart.png')
|
|
self.sprite = []
|
|
for parts in sprite:
|
|
with open(f'art/images/{parts}') as i:
|
|
self.sprite.append(pg.image.load(i))
|
|
|
|
|
|
class Level():
|
|
def __init__(self, x, y, level, width, height, text, font, font_size) -> None:
|
|
self.x = x
|
|
self.y = y
|
|
self.level = level
|
|
self.width = width
|
|
self.height = height
|
|
self.font = pg.font.Font(f'fonts/{fonts[font]}', font_size)
|
|
self.hidden = False
|
|
with open('art/images/label.png', 'r') as tb:
|
|
self.box = pg.image.load(tb)
|
|
self.box = pg.transform.scale(self.box, (width, height))
|
|
self.labelRect = pg.Rect(self.x, self.y, self.width, self.height)
|
|
self.labelSurf = self.font.render(text, True, '#1E90FF')
|
|
|
|
def draw(self, screen):
|
|
self.box.blit(self.labelSurf, [
|
|
self.labelRect.width / 2 - self.labelSurf.get_rect().width / 2,
|
|
self.labelRect.height / 2 - self.labelSurf.get_rect().height / 2
|
|
])
|
|
screen.blit(self.box, self.labelRect)
|
|
|
|
class Mobs(Fighter):
|
|
def __init__(self, name, ms, sprite, x, y, health, damage, level, asp, atr, drops) -> None:
|
|
super().__init__(name, ms, sprite, x, y, health, damage, level, asp, atr)
|
|
self.drops = drops * (self.level / 2)
|
|
|
|
class Skeleton(Mobs):
|
|
def __init__(self, name, ms, sprite, x, y, health, damage, level, asp, atr, drops=0) -> None:
|
|
super().__init__(name, ms, sprite, x, y, health, damage, level, asp, atr, drops)
|
|
|
|
def chase(self, obj):
|
|
x = obj[0][0].x
|
|
y = obj[0][0].y
|
|
moveto = vec(x, y) - vec(self.x, self.y)
|
|
if not (moveto).length() <= self.attack_range:
|
|
moveto.scale_to_length(self.speed)
|
|
self.x += moveto[0] / fps
|
|
self.y += moveto[1] / fps
|
|
else:
|
|
self.attack(moveto, obj)
|
|
|
|
def attack(self, moveto, obj):
|
|
if self.lastAttack + self.attack_speed * 1000 < pg.time.get_ticks():
|
|
obj[1].append(Arrow("arrow", 200, self.x, self.y, moveto, self.damage))
|
|
self.lastAttack = pg.time.get_ticks()
|
|
|
|
def update(self, obj):
|
|
self.chase(obj)
|
|
|
|
|
|
class Weapons(Objects):
|
|
def __init__(self, name, ms, sprite, x, y, moveto, damage) -> None:
|
|
super().__init__(name, ms, sprite, x, y)
|
|
self.moveto = moveto
|
|
self.damage = damage
|
|
|
|
|
|
class Arrow(Weapons):
|
|
def __init__(self, name, ms, x, y, moveto, damage, sprite="arrow.png") -> None:
|
|
super().__init__(name, ms, sprite, x, y, moveto, damage)
|
|
pos = vec(1,0)
|
|
angle = pos.angle_to(moveto)
|
|
with open(f'art/images/{sprite}') as i:
|
|
self.sprite = pg.transform.rotate(pg.image.load(i), -angle)
|
|
|
|
def move(self):
|
|
self.moveto.scale_to_length(self.speed)
|
|
self.x += self.moveto[0] / fps
|
|
self.y += self.moveto[1] / fps
|
|
|
|
def die(self, objects):
|
|
touches = pg.sprite.spritecollideany(self, objects[0])
|
|
if touches is not None and isinstance(touches, MainCharacter):
|
|
touches.hurt(self.damage)
|
|
self.hidden = True
|
|
|
|
def update(self, objects):
|
|
self.move()
|
|
self.die(objects)
|