Lyzzy/game
1
0
Fork 0
forked from InfoProjekt/game
Code Pull requests Activity

Merge pull request 'room update and boss' (#83) from Spafi/game:main into Development

Browse source 
Reviewed-on: InfoProjekt/game#83
This commit is contained in:
Spafi 2024-03-12 11:52:26 +00:00
commit 08edd05403
12 changed files with 1149 additions and 1085 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

BIN
__pycache__/classes.cpython-311.pyc Normal file
View file

Binary file not shown.

BIN
__pycache__/main.cpython-311.pyc Normal file
View file

Binary file not shown.

BIN
__pycache__/viecher.cpython-311.pyc Normal file
View file

Binary file not shown.

BIN
art/image files/door.kra~ Normal file
View file

Binary file not shown.

BIN
art/image files/field.kra~ Normal file
View file

Binary file not shown.

BIN
art/image files/startscreen.kra~ Normal file
View file

Binary file not shown.

BIN
art/image files/textbox.png~ Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 607 B

BIN
art/images/background/startscreen.png~ Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 4.3 MiB

BIN
art/images/people/fairy.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 1.7 KiB

728
classes.py
View file

@ -1,5 +1,6 @@
import pygame import pygame
import random import random
# from viecher import Skeleton, Zombie
pygame.font.init() pygame.font.init()
fonts = { fonts = {
@ -196,15 +197,15 @@ class Scene(GameObjects):
self.current_level = 0 self.current_level = 0
self.update() self.update()
def update(self, change:bool=False, objects=None): def update(self, change:int=None, objects=None):
if change: obj = self.level[self.current_level].update(change, objects)
self.current_level += 1
self.level[self.current_level].update(objects)
self.background = self.level[self.current_level].background self.background = self.level[self.current_level].background
"""if isinstance(self.objects, list): """if isinstance(self.objects, list):
for obj in self.objects[0] + self.objects[1] + self.objects[2]: for obj in self.objects[0] + self.objects[1] + self.objects[2]:
obj.update()""" obj.update()"""
return obj
def draw(self, screen): def draw(self, screen):
"""if isinstance(self.objects, list): """if isinstance(self.objects, list):
for obj in self.objects[0] + self.objects[1] + self.objects[2] + self.objects[3]: for obj in self.objects[0] + self.objects[1] + self.objects[2] + self.objects[3]:
@ -218,21 +219,29 @@ class Scene(GameObjects):
class Stage(GameObjects): class Stage(GameObjects):
def __init__(self, name: str, _type: str, bg, objects: list, WIDTH, HEIGHT, stage:str, rooms:list) -> None: def __init__(self, name: str, _type: str, bg, objects: list, WIDTH, HEIGHT, stage:str, rooms:list) -> None:
super().__init__(name, _type, bg, objects, WIDTH, HEIGHT) super().__init__(name, _type, bg, objects, WIDTH, HEIGHT)
self.WIDTH = WIDTH
self.HEIGHT = HEIGHT
self.stage = stage self.stage = stage
self.rooms = rooms self.rooms = rooms
self.current = 0 self.current = 0
self.sortRooms(WIDTH) self.sortRooms(WIDTH)
for room in self.rooms:
if room.id == self.current:
room.objectCreation(WIDTH, HEIGHT)
def update(self, objects): def update(self, target, objects):
if target is not None:
self.current = int(target)
for room in self.rooms:
if room.id == self.current:
obj = room.objectCreation(self.WIDTH, self.HEIGHT)
self.background = room.background
return obj
for room in self.rooms: for room in self.rooms:
if room.id == self.current: if room.id == self.current:
room.update(objects) room.update(objects)
self.background = room.background self.background = room.background
keys = pygame.key.get_pressed()
if keys[pygame.K_RIGHT]:
self.current += 1
if self.current >= len(self.rooms):
return 1
def draw(self, screen): def draw(self, screen):
for room in self.rooms: for room in self.rooms:
@ -269,7 +278,6 @@ class Stage(GameObjects):
room.exits.append([rooms[i + 2].id, rooms[i + 2].type]) room.exits.append([rooms[i + 2].id, rooms[i + 2].type])
for room in self.rooms: for room in self.rooms:
print(str(room.id) + str(room.exits))
room.createDoors(WIDTH) room.createDoors(WIDTH)
class Room(GameObjects): class Room(GameObjects):
@ -280,9 +288,9 @@ class Room(GameObjects):
self.doors = [] self.doors = []
if self.type == 'normal' or self.type == 'boss': if self.type == 'normal' or self.type == 'boss':
self.locked = True self.locked = True
#self.objectCreation(WIDTH, HEIGHT)
else: else:
self.locked = False self.locked = False
[self.objects[4].append(wall) for wall in self.genWalls(WIDTH, HEIGHT)]
def genWalls(self, WIDTH, HEIGHT): def genWalls(self, WIDTH, HEIGHT):
walls = [] walls = []
@ -295,7 +303,7 @@ class Room(GameObjects):
def createDoors(self, WIDTH): def createDoors(self, WIDTH):
if not self.type == 'boss': if not self.type == 'boss':
if len(self.exits) == 1: if len(self.exits) == 1:
self.doors.append(Door(f'door{self.id}', self.exits[0][1], random.randint(64, round(WIDTH * 0.75)), 4, self.exits[0][0])) self.doors.append(Door(f'door{self.id}', self.exits[0][1], random.randint(64, round(WIDTH * 0.75)), self.exits[0][0]))
elif len(self.exits) == 2: elif len(self.exits) == 2:
self.doors.append(Door(f'door{self.id}', self.exits[0][1], random.randint(64, round(WIDTH * 0.45)), self.exits[0][0])) self.doors.append(Door(f'door{self.id}', self.exits[0][1], random.randint(64, round(WIDTH * 0.45)), self.exits[0][0]))
self.doors.append(Door(f'door{self.id}', self.exits[1][1], random.randint(round(WIDTH * 0.5), round(WIDTH * 0.9)), self.exits[1][0])) self.doors.append(Door(f'door{self.id}', self.exits[1][1], random.randint(round(WIDTH * 0.5), round(WIDTH * 0.9)), self.exits[1][0]))
@ -304,11 +312,32 @@ class Room(GameObjects):
self.doors.append(Door(f'door{self.id}', self.exits[1][1], random.randint(round(WIDTH * 0.33), round(WIDTH * 0.6)), self.exits[1][0])) self.doors.append(Door(f'door{self.id}', self.exits[1][1], random.randint(round(WIDTH * 0.33), round(WIDTH * 0.6)), self.exits[1][0]))
self.doors.append(Door(f'door{self.id}', self.exits[2][1], random.randint(round(WIDTH * 0.63), round(WIDTH * 0.95)), self.exits[2][0])) self.doors.append(Door(f'door{self.id}', self.exits[2][1], random.randint(round(WIDTH * 0.63), round(WIDTH * 0.95)), self.exits[2][0]))
self.objects.append(self.doors)
def objectCreation(self, WIDTH, HEIGHT):
if self.type != 'boss':
self.objects[1] = [Skeleton('skeleton', random.randint(40, 60), random.randint(50, WIDTH - 50), random.randint(50, HEIGHT - 50), 5, 1, 1, 2, 200) for i in range(0,random.randint(2, 5))] + [Zombie('zombie', random.randint(40, 60), random.randint(50, WIDTH-50), random.randint(50, HEIGHT-50), 5, 1, 1, 1, 25) for i in range(0,random.randint(2, 5))]
npcs = [NPC('vivi', 100, 'people/vivi.png', 0, 400, 600),
NPC('fairy', 100, 'people/fairy.png', 0, 200, 200)]
rand = random.randint(0, 30)
if rand <= 25 and rand >= 15:
self.objects[2] = [random.choice(npcs)]
else:
self.objects[1] = [Boss('reddy', 40, WIDTH / 2 - 16, HEIGHT /2 - 32, 50, 0.1, 1, 5, 5000)]
self.objects[4] = [wall for wall in self.genWalls(WIDTH, HEIGHT)]
return self.objects
def update(self, objects): def update(self, objects):
if objects is not None: if objects is not None:
self.objects = objects self.objects = objects
if not self.objects[1]: if not self.objects[1]:
if self.type == 'boss':
print('yeahhh, you killed the boss')
self.objects[0][0].level.level = 100
self.locked = False self.locked = False
for door in self.doors:
door.update(False)
return return
def draw(self, screen): def draw(self, screen):
@ -339,13 +368,682 @@ class Obstacle(GameObjects):
screen.blit(self.background, self.rect) screen.blit(self.background, self.rect)
class Door(GameObjects): class Door(GameObjects):
def __init__(self, name: str, _type: str, x: int, target:int, y: int=8, objects: list=None, WIDTH=None, HEIGHT=None, islocked=True) -> None: def __init__(self, name: str, _type: str, x: int, target:int, y: int=16, objects: list=None, WIDTH=None, HEIGHT=None, islocked=True) -> None:
super().__init__(name, _type, f'art/images/background/door_{_type}.png', objects, WIDTH, HEIGHT) super().__init__(name, _type, f'art/images/background/door_{_type}.png', objects, WIDTH, HEIGHT)
self.rect = pygame.Rect((x, y), self.background.get_size()) self.rect = pygame.Rect((x, y), self.background.get_size())
self.locked = islocked self.locked = islocked
self.target = target
def draw(self, screen): def draw(self, screen):
screen.blit(self.background, self.rect) screen.blit(self.background, self.rect)
def update(self, islocked=True): def update(self, islocked=True):
self.locked = islocked self.locked = islocked
#Viecher
vec = pygame.math.Vector2
fps = 60
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 = pygame.transform.scale2x(pygame.image.load(i))
self.x = x
self.y = y
self.hidden = False
self.rect = pygame.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)
#pygame.draw.rect(screen, '#ef0120', self.rect, 2)
class NPC(Objects):
def __init__(self, name, ms, sprite, convo_scene, x, y) -> None:
super().__init__(name, ms, sprite, x, y)
self.talking = False
self.hidden = False
self.conversation = Convo(self, convo_scene)
self.lastUpdate = pygame.time.get_ticks()
def talk(self, objects):
self.talking = True
objects[0][0].talking = True
def draw(self, screen):
super().draw(screen)
if self.talking:
self.conversation.draw(screen)
def update(self, keys, objects):
if self.name == 'oldlady':
if self.conversation.convo_scene == 0 and 'rat' in objects[0][0].killed and objects[1]==[]:
self.conversation.convo_scene = 1
if self.lastUpdate + 200 < pygame.time.get_ticks():
if self.talking:
self.conversation.update(keys, objects)
self.lastUpdate = pygame.time.get_ticks()
else:
touches = pygame.sprite.spritecollideany(self, objects[0])
if touches is not None and keys[pygame.K_f] and isinstance(touches, MainCharacter):
self.talk(objects)
self.lastUpdate = pygame.time.get_ticks()
class Convo(Label):
def __init__(self, npc, convo_scene, text='', x = 140, y = 600, width = 1000, height = 100, font='simple', font_size = 20) -> None:
super().__init__(x, y, width, height, text, font, font_size)
self.convo_act=0
self.npc = npc
self.convo_scene = convo_scene
self.convos = [
['oldlady', 0, ['There are so many rats here.', 'I wish someone would to something against that.','An experienced fighter could kill them.', 'For them it only takes a mouseclick.']],
['oldlady', 1, ['Oh, did you kill all the rats?', 'You must be the chosen one!', 'It would be nice if you would go and talk to the village elder.']],
['elder', 0, ['Who are you?', 'You want to help us?', 'We have a serious problem with monsters.', 'One day they appeared out of nowhere and started attacking.', 'When you jump into the portal over there,', 'You will be send to a place with monsters.', 'PLEASE help us!']],
['elder', 1, ['Who are you?', 'You want to help us?', 'We have a serious problem with monsters.', 'One day they appeared out of nowhere and started attacking.', 'When you jump into the portal over there,', 'You will be send to a place with monsters.', 'PLEASE help us!']],
['vivi', 0, ['Wer bist du denn?', 'Aber du kannst gerne aus dem Fenster springen, solange es nicht in meinem Unterricht ist.']]
]
def draw(self, screen):
self.text = self.findConversation()[2][self.convo_act]
super().draw(screen)
def findConversation(self):
for convo in self.convos:
if convo[0] == self.npc.name and convo[1] == self.convo_scene:
return convo
return ['ERROR']
def update(self, keys, objects):
if keys[pygame.K_f]:
convo = self.findConversation()
if self.convo_act + 1 < len(convo[2]):
self.text = convo[2][self.convo_act]
self.convo_act += 1
else:
if convo[0] == 'oldlady':
if convo[1] == 0:
for i in range(0,5):
objects[1].append(Rat('rat', random.randint(150,250), 800, 400+i*20, 1, 1, 1, 100, 25))
elif convo[1] == 1:
objects[0][0].level.level = 50
while 'rat' in objects[0][0].killed: objects[0][0].killed.remove('rat')
elif convo[0] == 'elder':
if convo[1] == 0:
objects[4].append(Obstacle('portal', 'interactable', 'art/images/background/portal.png', False, 700, 300))
self.convo_scene += 1
elif convo[0] == 'vivi':
objects[0][0].health.health = 0
self.convo_act = 0
self.npc.talking = False
objects[0][0].talking = False
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 = pygame.time.get_ticks()
self.lastAttack = pygame.time.get_ticks()
self.hurtCooldown = 0
class MainCharacter(Fighter):
def __init__(self, name, ms, sprite, x, y, health, damage, level, asp, atr, killed=[]) -> None:
super().__init__(name, ms, sprite, x, y, health, damage, level, asp, atr)
self.book = Book(0, 0, [], None, None)
self.talking = False
self.level = Level(1000, 38, 150, 40, level, 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, hurtCooldown=self.hurtCooldown)
self.thinks = Thinks(self.x + 20, self.y - 50, 150, 100, 'brr I\'m freezing')
self.freezing = True
self.killed = killed # amount of mobs that were killed
self.load_frames(f'art/images/people/oldmanwalk.png', f'art/images/people/oldmanattack.png')
self.current_frame = 0
self.animation_speed = 0.1
self.last_frame_update = pygame.time.get_ticks()
self.rect = pygame.Rect(x, y, self.walk_frames[0].get_width(), self.walk_frames[0].get_height())
self.is_attacking = False
def load_frames(self, walk_sprite_sheet, attack_sprite_sheet):
self.walk_frames = self.load_animation_frames(walk_sprite_sheet, frame_width=40, frame_height=66)
self.attack_frames = self.load_animation_frames(attack_sprite_sheet, frame_width=66, frame_height=64) # Adjust frame width and height as needed
def load_animation_frames(self, sprite_sheet, frame_width, frame_height):
sprite_sheet = pygame.transform.scale2x(pygame.image.load(sprite_sheet))
animation_frames = []
if frame_width == 40:
frames_coordinates = [
(frame_width, 0),
(frame_width*2, 0),
(frame_width*3, 0),
(frame_width*4, 0),
(frame_width*5, 0),
(frame_width*6, 0),
(frame_width*7, 0),
(frame_width*8, 0),
]
else:
frames_coordinates = [
(frame_width, 0),
(frame_width*2, 0),
(frame_width*3, 0),
(frame_width*4, 0),
(frame_width*5, 0),
(frame_width*6, 0)
]
for x, y in frames_coordinates:
frame = pygame.Surface((frame_width, frame_height), pygame.SRCALPHA)
frame.blit(sprite_sheet, (0, 0), (x, y, frame_width, frame_height))
animation_frames.append(frame)
return animation_frames
def draw(self, screen):
if self.hidden:
return
current_time = pygame.time.get_ticks()
if self.is_attacking:
animation_frames = self.attack_frames
else:
animation_frames = self.walk_frames
if current_time - self.last_frame_update > self.animation_speed * 1000:
self.current_frame = (self.current_frame + 1) % len(animation_frames)
self.last_frame_update = current_time
current_frame_image = animation_frames[self.current_frame]
screen.blit(current_frame_image, (self.x, self.y))
self.rect.x, self.rect.y = self.x, self.y
self.health.draw(screen)
self.level.draw(screen)
self.book.draw(screen)
#pygame.draw.rect(screen, '#e900fa', self.rect, 2)
if self.thinks.hidden == False:
self.thinks.draw(screen, self.x + 20, self.y - 100)
def hurt(self, damage, objects):
if not self.talking:
self.health.hurt(damage)
def obstacle_interaction(self, objects):
if len(objects) <= 5:
objects.append([])
touches = pygame.sprite.spritecollideany(self, objects[4] + objects[5])
if touches is not None:
if touches.name == 'fireplace':
self.freezing = False
elif touches.name == 'portal' and self.level.level != 1:
return 'play'
elif touches.name == 'house' and self.level.level != 1:
self.x = 500
self.y = 400
return 'house'
elif 'wall' in touches.name:
return 'wall'
elif isinstance(touches, Door):
if not touches.locked:
return f'door-{touches.target}'
else:
return True
def walk(self, keys, objects):
moveto = vec(0, 0)
if keys[pygame.K_w] or keys[pygame.K_UP]:
moveto += vec(0, -1)
if keys[pygame.K_a] or keys[pygame.K_LEFT]:
moveto += vec(-1, 0)
if keys[pygame.K_s] or keys[pygame.K_DOWN]:
moveto += vec(0, 1)
if keys[pygame.K_d] or keys[pygame.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 = pygame.sprite.spritecollideany(self, objects[4])
if touches is not None and not isinstance(touches, Weapons):
if isinstance(touches, Obstacle):
if not touches.collision:
# print(touches.name)
return
if touches.type == 'wall':
if touches.name == 'wall_l':
self.x += (2 + (self.x - touches.rect.x))
elif touches.name == 'wall_r':
self.x -= (2 + self.rect.width - (touches.rect.x - self.x))
if touches.name == 'wall_t':
self.y += (2 + (self.y - touches.rect.y))
elif touches.name == 'wall_b':
self.y -= (2 + self.rect.height - (touches.rect.y - self.y))
return
if self.x <= touches.rect.x: self.x -= (self.rect.width - (touches.rect.x - self.x))
elif self.x > touches.rect.x: self.x += (self.rect.width - (self.x - touches.rect.x - touches.rect.width * 0.7))
#if self.y <= touches.y: pass
#elif self.y > touches.y: pass
#self.x -= moveto[0] * 2 / fps
#self.y -= moveto[1] * 2 / fps
"""
if self.x <= 32:
self.x = 33
elif self.x >= objects[3][0].width - 32:
self.x = objects[3][0].width - 32 - self.rect.width + 1
if self.y <= 32:
self.y = 33
elif self.y >= objects[3][0].height - 32:
self.y = objects[3][0].height - 32 - self.rect.height + 1
"""
def attack(self, obj, mouse):
if self.lastAttack + self.attack_speed * 1000 < pygame.time.get_ticks():
moveto = mouse - vec(self.x, self.y)
if self.book.current_sp == 'fireball':
weapon = Fireball('fb1', 100, self.x, self.y, moveto, 5)
elif self.book.current_sp == 'windslash':
weapon = Windslash('ws1', 100, self.x, self.y, moveto, 10)
else:
weapon = Punch('punch', 100, self.x, self.y, moveto, 1, Mobs, life_ticks=500)
obj[3].append(weapon)
self.lastAttack = pygame.time.get_ticks()
if not self.is_attacking:
self.current_frame = 0
self.is_attacking = True
def update(self, keys, mouse, objects):
if not self.talking:
is_moving = False
if keys[pygame.K_w] or keys[pygame.K_UP] or keys[pygame.K_a] or keys[pygame.K_LEFT] or keys[pygame.K_s] or keys[pygame.K_DOWN] or keys[pygame.K_d] or keys[pygame.K_RIGHT]:
is_moving = True
if is_moving:
self.walk(keys, objects)
self.is_attacking = False
else:
current_time = pygame.time.get_ticks()
if current_time - self.last_frame_update > self.animation_speed * 1000:
self.current_frame = (self.current_frame + 1) % len(self.walk_frames)
self.last_frame_update = current_time
if not self.is_attacking:
self.current_frame = 0
if pygame.mouse.get_pressed()[0]:
self.attack(objects, vec(mouse))
if self.is_attacking:
if self.current_frame == len(self.attack_frames) - 1:
self.is_attacking = False
self.current_frame = 0
self.thinks.update(objects, self)
if self.health.health <= 0:
return 'village'
else:
return self.obstacle_interaction(objects)
class Hearts():
def __init__(self, health, sprite, x, y, hurtCooldown) -> None:
self.x = x
self.y = y
self.health = health
self.lastHurt = pygame.time.get_ticks()
self.hurtCooldown = hurtCooldown
self.hidden = False
self.sprite=[]
for parts in sprite:
with open(f'art/images/main_attributes/{parts}') as i:
self.sprite.append(pygame.image.load(i))
self.rect = []
for each in self.sprite:
self.rect.append(pygame.Rect(self.x, self.y, each.get_width(), each.get_height()))
def hurt(self,damage):
if self.lastHurt + self.hurtCooldown < pygame.time.get_ticks():
self.health -= damage
self.lastHurt = pygame.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 round(self.health) >= 4 + 4 * i:
sprite.append('fullheart.png')
elif round(self.health) == 3 + 4 * i:
sprite.append('dreiviertelheart.png')
elif round(self.health) >= 2 + 4 * i:
sprite.append('halfheart.png')
elif round(self.health) >= 1 + 4 * i:
sprite.append('viertelheart.png')
elif round(self.health) <= 4 * i:
sprite.append('noheart.png')
self.sprite = []
for parts in sprite:
with open(f'art/images/main_attributes/{parts}') as i:
self.sprite.append(pygame.image.load(i))
class Level(Label):
def __init__(self, x, y, width, height, level, text, font='simple', font_size=20, font_color='#1e90ff', sprite='label.png') -> None:
super().__init__(x, y, width, height, text, font, font_size, font_color, sprite)
self.level = level
def draw(self, screen):
self.text = f'will to live: {self.level}%'
super().draw(screen)
class Thinks(Label):
def __init__(self, x, y, width, height, text, font='simple', font_size=15, font_color='#000000', sprite='thinks.png') -> None:
super().__init__(x, y, width, height, text, font, font_size, font_color, sprite)
self.scene = 0
def draw(self, screen, x, y):
if self.hidden:
return
self.x = x
self.y = y
super().draw(screen)
def update(self, objects, main):
if not self.hidden:
if self.scene == 0 and not main.freezing:
self.scene = 1
self.hidden = True
elif self.scene == 1 and main.talking:
self.scene = 2
self.hidden = True
if self.scene == 1:
touches = pygame.sprite.spritecollideany(main, objects[2])
if touches is not None and isinstance(touches, NPC):
self.text = 'I should press \"f\"'
self.hidden = False
else:
self.hidden = False
self.text = 'the lady over there'
class Book():
def __init__(self, x, y, spells, current_spell, current_shield) -> None:
with open(f'art/images/main_attributes/book.png') as i:
self.sprite = pygame.image.load(i)
self.sprite = pygame.transform.scale(self.sprite, (1280, 720))
self.x = x
self.y = y
self.hidden = False
self.rect = pygame.Rect(self.x, self.y, self.sprite.get_width(), self.sprite.get_height())
self.sp_list = spells
self.current_sp = current_spell
self.text_left = ["Dear User, ", "in case you fell on the ground too hard,", "here is a quick reminder:",
"You are a homeless person. One cold day","you went to the library to warm up yourself.",
"There you got bored and found and opened me.", "This lead to you being thrown into this world.",
"But you can find a way out of here again."]
self.text_right = ["This book will help you to survive.", "You can open and close me when pressing e.",
"Click on a picture to choose your spell.",
"Talk to fairies to unlock new spells!"]
self.buttons=[]
self.buttons_y = 400
self.buttons_x = 800
def draw(self, screen):
if self.hidden:
return
self.rect.x, self.rect.y = self.x, self.y
screen.blit(self.sprite, self.rect)
text_left_y = 100
text_right_y = 100
for text in self.text_left:
label = Label(100, text_left_y, 500, 50, text, font_color='#000000', sprite='empty.png')
label.draw(screen)
text_left_y += 50
for text in self.text_right:
label = Label(680, text_right_y, 500, 50, text, font_color='#000000', sprite='empty.png')
label.draw(screen)
text_right_y += 50
for button in self.buttons:
button.update(screen)
def addspell(self, spell):
if spell not in self.sp_list:
self.sp_list.append(spell)
self.current_sp = spell
self.buttons.append(Button(self.buttons_x, self.buttons_y, 58, 50, f'{spell}_icon.png', 'medieval', 23, attributes=[spell], onclickFunction=self.update_spell))
self.buttons_y += 100
def update_spell(self, spell):
self.current_sp = spell
def update(self):
pass
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)
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
touches = pygame.sprite.spritecollideany(self, obj[4])
if touches is not None and not isinstance(touches, Weapons):
if isinstance(touches, Obstacle):
if not touches.collision:
return
if touches.type == 'wall':
if touches.name == 'wall_l':
self.x += (2 + (self.x - touches.rect.x))
elif touches.name == 'wall_r':
self.x -= (2 + self.rect.width - (touches.rect.x - self.x))
if touches.name == 'wall_t':
self.y += (2 + (self.y - touches.rect.y))
elif touches.name == 'wall_b':
self.y -= (2 + self.rect.height - (touches.rect.y - self.y))
if self.x <= touches.rect.x: self.x -= (self.rect.width - (touches.rect.x - self.x))
elif self.x > touches.rect.x: self.x += (self.rect.width - (self.x - touches.rect.x - touches.rect.width * 0.66))
else:
self.attack(moveto, obj)
def hurt(self, damage, objects):
self.health -= damage
if self.health <= 0:
objects[0][0].killed.append(self.name)
self.hidden = True
objects[1].remove(self)
def update(self, obj):
self.chase(obj)
class Skeleton(Mobs):
def __init__(self, name, ms, x, y, health, damage, level, asp, atr, sprite = 'people/skeleton.png', drops=0) -> None:
super().__init__(name, ms, sprite, x, y, health, damage, level, asp, atr, drops)
def attack(self, moveto, obj):
if self.lastAttack + self.attack_speed * 1000 < pygame.time.get_ticks():
obj[3].append(Arrow("arrow", 200, self.x, self.y, moveto, self.damage))
self.lastAttack = pygame.time.get_ticks()
class Zombie(Mobs):
def __init__(self, name, ms, x, y, health, damage, level, asp, atr, sprite_sheet='people/zombiewalk.png', drops=0) -> None:
super().__init__(name, ms, sprite_sheet, x, y, health, damage, level, asp, atr, drops)
self.load_frames(f'art/images/{sprite_sheet}')
self.current_frame = 0
self.animation_speed = 250
self.last_frame_update = pygame.time.get_ticks()
self.hidden = False
self.rect = pygame.Rect(x, y, 40, 64)
def load_frames(self, sprite_sheet):
sprite_sheet = pygame.transform.scale2x(pygame.image.load(sprite_sheet).convert_alpha())
frame_width = 40
frame_height = 64
frames_coordinates = [(40, 0),(80, 0),(120, 0),(160, 0),(200, 0),(240, 0),(280, 0), (320, 0)]
self.animation_frames = []
for x, y in frames_coordinates:
frame = pygame.Surface((frame_width, frame_height), pygame.SRCALPHA)
frame.blit(sprite_sheet, (0, 0), (x, y, frame_width, frame_height))
self.animation_frames.append(frame)
def draw(self, screen):
if self.hidden:
return
current_time = pygame.time.get_ticks()
if current_time - self.last_frame_update > self.animation_speed:
self.current_frame = (self.current_frame + 1) % len(self.animation_frames)
self.last_frame_update = current_time
current_frame_image = self.animation_frames[self.current_frame]
screen.blit(current_frame_image, (self.x, self.y))
self.rect.topleft = (self.x, self.y)
#pygame.draw.rect(screen, '#ef0120', self.rect, 2)
def attack(self, moveto, obj):
if self.lastAttack + self.attack_speed * 1000 < pygame.time.get_ticks():
obj[3].append(Punch('punch', 100, self.x, self.y, moveto, self.damage, MainCharacter))
self.lastAttack = pygame.time.get_ticks()
class Rat(Mobs):
def __init__(self, name, ms, x, y, health, damage, level, asp, atr, sprite='people/rat.png', drops=0) -> None:
super().__init__(name, ms, sprite, x, y, health, damage, level, asp, atr, drops)
def attack(self, moveto, obj):
if self.lastAttack + self.attack_speed * 1000 < pygame.time.get_ticks():
obj[3].append(Punch('punch', 100, self.x, self.y, moveto, self.damage, MainCharacter))
self.lastAttack = pygame.time.get_ticks()
class Boss(Mobs):
def __init__(self, name, ms, x, y, health, damage, level, asp, atr, sprite='people/reddy.png', drops=0) -> None:
super().__init__(name, ms, sprite, x, y, health, damage, level, asp, atr, drops)
def attack(self, moveto, obj):
if self.lastAttack + self.attack_speed * 1000 < pygame.time.get_ticks():
obj[3].append(RedBlob("blob", 50, self.x, self.y, moveto, self.damage))
self.lastAttack = pygame.time.get_ticks()
def hurt(self, damage, objects, ticks):
if ticks > 1000:
damage /= 2
self.health -= damage
if self.health <= 0:
objects[0][0].killed.append(self.name)
self.hidden = True
objects[1].remove(self)
class Weapons(Objects):
def __init__(self, name, ms, sprite, x, y, moveto, damage, life_ticks) -> None:
super().__init__(name, ms, sprite, x, y)
self.moveto = moveto
self.damage = damage
self.life_ticks= life_ticks
self.spawn_tick = pygame.time.get_ticks()
pos = vec(1,0)
angle = pos.angle_to(moveto)
self.sprite = pygame.transform.rotate(self.sprite, -angle)
def die(self, objects, kills):
touches = pygame.sprite.spritecollideany(self, objects[0] + objects[1])
if kills == Mobs:
if touches is not None and isinstance(touches, Boss):
touches.hurt(self.damage, objects, self.life_ticks)
self.hidden = True
if self in objects[3]:
objects[3].remove(self)
return
if touches is not None and isinstance(touches, kills):
touches.hurt(self.damage, objects)
self.hidden = True
if self in objects[3]:
objects[3].remove(self)
def move(self, objects):
self.moveto.scale_to_length(self.speed)
self.x += self.moveto[0] / fps
self.y += self.moveto[1] / fps
if pygame.time.get_ticks() - self.spawn_tick > self.life_ticks:
self.hidden = True
objects[3].remove(self)
class Spells(Weapons):
def __init__(self, name, ms, sprite, x, y, moveto, damage, life_ticks) -> None:
super().__init__(name, ms, sprite, x, y, moveto, damage, life_ticks)
class Fireball(Spells):
def __init__(self, name, ms, x, y, moveto, damage, sprite = 'weapons/fireball.png', life_ticks=5000) -> None:
super().__init__(name, ms, sprite, x, y, moveto, damage, life_ticks)
def update(self, objects):
self.move(objects)
self.die(objects, Mobs)
class Windslash(Spells):
def __init__(self, name, ms, x, y, moveto, damage, sprite = 'weapons/windslash.png', life_ticks=1000) -> None:
super().__init__(name, ms, sprite, x, y, moveto, damage, life_ticks)
def update(self, objects):
self.move(objects)
self.die(objects, Mobs)
def move(self, objects):
super().move(objects)
self.moveto = self.moveto.rotate(5)
class RedBlob(Spells):
def __init__(self, name, ms, x, y, moveto, damage, sprite = 'weapons/redblob.png', life_ticks=50000) -> None:
super().__init__(name, ms, sprite, x, y, moveto, damage, life_ticks)
def die(self, objects, kills):
touches = pygame.sprite.spritecollideany(self, objects[0] + objects[1])
if touches is not None and isinstance(touches, kills):
touches.hurt(self.damage, objects)
def update(self, objects):
self.move(objects)
self.die(objects, MainCharacter)
class Arrow(Weapons):
def __init__(self, name, ms, x, y, moveto, damage, sprite = 'weapons/arrow.png', life_ticks=5000) -> None:
super().__init__(name, ms, sprite, x, y, moveto, damage, life_ticks)
def update(self, objects):
self.move(objects)
self.die(objects, MainCharacter)
class Punch(Weapons):
def __init__(self, name, ms, x, y, moveto, damage, kills, sprite = 'weapons/empty.png', life_ticks=100) -> None:
super().__init__(name, ms, sprite, x, y, moveto, damage, life_ticks)
self.kills = kills
def update(self, objects):
self.move(objects)
self.die(objects, self.kills)

850
main.py
View file

@ -1,414 +1,436 @@
import pygame import pygame
import sys import sys
import json import json
import time import time
import random import random
from classes import * from classes import *
from viecher import * # from viecher import *
from pygame import mixer from pygame import mixer
fps = 60 fps = 60
def setUp(config): def setUp(config):
pygame.init() pygame.init()
mixer.music.load('audio/music/thebritons(1.1).mp3') mixer.music.load('audio/music/thebritons(1.1).mp3')
mixer.music.play(-1) mixer.music.play(-1)
if config["fullscreen"]: if config["fullscreen"]:
screen = pygame.display.set_mode(config["res"], pygame.FULLSCREEN) screen = pygame.display.set_mode(config["res"], pygame.FULLSCREEN)
else: else:
screen = pygame.display.set_mode(config["res"]) screen = pygame.display.set_mode(config["res"])
clock = pygame.time.Clock() clock = pygame.time.Clock()
pygame.display.set_caption('Between The Pages') pygame.display.set_caption('Between The Pages')
with open('art/images/icon.png', 'r') as i: with open('art/images/icon.png', 'r') as i:
pygame.display.set_icon(pygame.image.load(i)) pygame.display.set_icon(pygame.image.load(i))
return screen, clock, True, True, "startscreen.png", [] return screen, clock, True, False, "startscreen.png", []
def readConfig(): def readConfig():
with open('config.json', 'r') as c: with open('config.json', 'r') as c:
json_data = c.read() json_data = c.read()
return json.loads(json_data) return json.loads(json_data)
def quitGame(): def quitGame():
#save progress somehow, if needed #save progress somehow, if needed
pygame.quit() pygame.quit()
quit() quit()
def genRooms(WIDTH, HEIGHT, type:str, objects:list): def genRooms(WIDTH, HEIGHT, type:str, objects:list):
room_objects = [] room_objects = []
#room_objects = [Obstacle('dirt', 'boulder', 'art/images/dirt2.png', False, 32, 32, WIDTH=WIDTH - 64, HEIGHT=HEIGHT - 64)] #room_objects = [Obstacle('dirt', 'boulder', 'art/images/dirt2.png', False, 32, 32, WIDTH=WIDTH - 64, HEIGHT=HEIGHT - 64)]
room_objects.append(Obstacle('river', 'water', 'art/images/background/river.png', True, random.randint(32, round(WIDTH * 0.75)), 32, WIDTH=96, HEIGHT=round(HEIGHT * 0.66))) room_objects.append(Obstacle('river', 'water', 'art/images/background/river.png', True, random.randint(32, round(WIDTH * 0.75)), 32, WIDTH=96, HEIGHT=round(HEIGHT * 0.66)))
room_backgrounds = [f'art/images/background/{type}{i}.png' for i in range(1)] room_backgrounds = [f'art/images/background/{type}{i}.png' for i in range(1)]
rooms = [ rooms = [
Room(type, 'normal', room_backgrounds[random.randint(0, 0)], [objects[0], objects[1], objects[2], objects[3], objects[4] + [room_objects[random.randint(0, 0)] for i in range(0, random.randint(0, 1))]], WIDTH - 64, HEIGHT - 64, j) Room(type, 'normal', room_backgrounds[random.randint(0, 0)], [objects[0], objects[1], objects[2], objects[3], objects[4] + [room_objects[random.randint(0, 0)] for i in range(0, random.randint(0, 1))]], WIDTH - 64, HEIGHT - 64, j)
for j in range(random.randint(5, 10)) for j in range(random.randint(1, 1))
] ]
rooms.append(Room(type, 'boss', room_backgrounds[random.randint(0, 0)], [objects[0], objects[1], [], [], objects[4] + [room_objects[random.randint(0, 0)] for i in range(0, random.randint(0, 1))]], WIDTH - 64, HEIGHT - 64, 88)) rooms.append(Room(type, 'boss', room_backgrounds[random.randint(0, 0)], [objects[0], objects[1], [], [], objects[4] + [room_objects[random.randint(0, 0)] for i in range(0, random.randint(0, 1))]], WIDTH - 64, HEIGHT - 64, 88))
#rooms =Room(type, 'normal', room_backgrounds[random.randint(0, 4)], [objects[0], objects[1], objects[2], [room_objects[random.randint(0, len(room_objects) - 1)] for i in range(0, random.randint(0, 1))]], WIDTH - 64, HEIGHT - 64, [True, True, True, True], j) #rooms = [Room(type, 'boss', room_backgrounds[random.randint(0, 0)], [objects[0], objects[1], [], [], objects[4] + [room_objects[random.randint(0, 0)] for i in range(0, random.randint(0, 1))]], WIDTH - 64, HEIGHT - 64, 88)]
#rooms =Room(type, 'normal', room_backgrounds[random.randint(0, 4)], [objects[0], objects[1], objects[2], [room_objects[random.randint(0, len(room_objects) - 1)] for i in range(0, random.randint(0, 1))]], WIDTH - 64, HEIGHT - 64, [True, True, True, True], j)
return rooms
return rooms
def play(screen, clock, running, background, isblack, WIDTH, HEIGHT):
main = [herbert] def play(screen, clock, running, background, isblack, WIDTH, HEIGHT):
mobs = [Skeleton('skeleton', random.randint(40, 60), random.randint(50, WIDTH - 50), random.randint(50, HEIGHT - 50), 5, 1, 1, 1, 200) for i in range(0,random.randint(2, 5))]+[Zombie('zombie', random.randint(40, 60), random.randint(50, WIDTH-50), random.randint(50, HEIGHT-50), 5, 1, 1, 1, 25) for i in range(0,random.randint(2, 5))] main = [herbert]
weapons = [] mobs = [Skeleton('skeleton', random.randint(40, 60), random.randint(50, WIDTH - 50), random.randint(50, HEIGHT - 50), 5, 1, 1, 1, 200) for i in range(0,random.randint(2, 5))]+[Zombie('zombie', random.randint(40, 60), random.randint(50, WIDTH-50), random.randint(50, HEIGHT-50), 5, 1, 1, 1, 25) for i in range(0,random.randint(2, 5))]
others = [] weapons = []
npcs = [] others = []
objects = [main, mobs, npcs, weapons, others] npcs = []
level = [] objects = [main, mobs, npcs, weapons, others]
rooms = genRooms(WIDTH, HEIGHT, 'grass', objects) level = []
level.append(Stage('blau', 'normal', None, [], WIDTH, HEIGHT, 'blue', rooms)) rooms = genRooms(WIDTH, HEIGHT, 'grass', objects)
scene = Scene('test', 'normal', None, None, WIDTH, HEIGHT, level) level.append(Stage('blau', 'normal', None, [], WIDTH, HEIGHT, 'blue', rooms))
freeze = False #Gameplay is freezed in certain situations scene = Scene('test', 'normal', None, None, WIDTH, HEIGHT, level)
freeze = False #Gameplay is freezed in certain situations
while running: tbc = Label(WIDTH / 2 - 128, HEIGHT / 2 - 32, 256, 32, "To be continued", "damaged", 30, '#ffffff', 'empty.png')
screen.fill('#000000') tbc_tick = 0
events = pygame.event.get() objects = scene.getObjects()
for event in events:
if event.type == pygame.QUIT: while running:
quitGame() screen.fill('#000000')
elif event.type == pygame.KEYDOWN: events = pygame.event.get()
if event.key == pygame.K_e: #when book is open gameplay is freezed for event in events:
freeze = not freeze if event.type == pygame.QUIT:
# RENDER YOUR GAME HERE quitGame()
"""with open(background, 'r') as i: elif event.type == pygame.KEYDOWN:
bg = pygame.image.load(i) if event.key == pygame.K_e: #when book is open gameplay is freezed
bg = pygame.transform.scale(bg, (WIDTH, HEIGHT)) freeze = not freeze
# fill the screen with an image to clear the screen # RENDER YOUR GAME HERE
screen.blit(bg, (0, 0)) """with open(background, 'r') as i:
""" bg = pygame.image.load(i)
if not freeze: bg = pygame.transform.scale(bg, (WIDTH, HEIGHT))
objects = scene.getObjects() # fill the screen with an image to clear the screen
screen.blit(scene.background, (32, 32)) screen.blit(bg, (0, 0))
"""
for thing in objects[4]: if isblack:
thing.draw(screen) if tbc_tick == 0:
tbc_tick = pygame.time.get_ticks()
for weapon in objects[3]: elif tbc_tick + 5000 <= pygame.time.get_ticks():
weapon.update(objects) quitGame()
weapon.draw(screen) tbc.draw(screen)
for thing in objects[0]: elif not freeze:
thing.book.hidden = not freeze screen.blit(scene.background, (32, 32))
result = thing.update(pygame.key.get_pressed(), pygame.mouse.get_pos(), objects) target = None
if result == 'village':
village(screen, clock, running, background, isblack, WIDTH, HEIGHT) for thing in objects[4]:
elif result == 'play': thing.draw(screen)
play(screen, clock, running, background, isblack, WIDTH, HEIGHT)
else: for weapon in objects[3]:
thing.draw(screen) weapon.update(objects)
weapon.draw(screen)
for mob in objects[1]:
mob.update(objects) for thing in objects[0]:
mob.draw(screen) thing.book.hidden = not freeze
result = thing.update(pygame.key.get_pressed(), pygame.mouse.get_pos(), objects)
for npc in objects[2]: if objects[0][0].level.level >= 100:
npc.update(pygame.key.get_pressed(), objects) isblack = True
npc.draw(screen) if isinstance(result, str):
if result == 'village':
objects[0][0].book.addspell('windslash') village(screen, clock, running, background, isblack, WIDTH, HEIGHT)
scene.update(False, objects) elif result == 'play':
scene.draw(screen) play(screen, clock, running, background, isblack, WIDTH, HEIGHT)
elif 'door-' in result:
else: target = result.split('-')[1]
objects[0][0].book.hidden = not freeze objects[0][0].level.level += 25
objects[0][0].book.draw(screen) objects = scene.update(target, objects)
objects[0][0].book.update() #play(screen, clock, running, background, isblack, WIDTH, HEIGHT)
# flip() the display to put your work on screen else:
pygame.display.flip() thing.draw(screen)
else:
clock.tick(fps) # limits FPS to 60 thing.draw(screen)
def village(screen, clock, running, background, isblack, WIDTH, HEIGHT): for mob in objects[1]:
main = [herbert] mob.update(objects)
mobs = [] mob.draw(screen)
weapons = []
others = [Obstacle('fireplace', 'interactable', 'art/images/background/fireplace.png', False, 200, 500), for npc in objects[2]:
Obstacle('house', 'Interactable', 'art/images/background/house.png', False, 500, 150, WIDTH=180, HEIGHT=160)] npc.update(pygame.key.get_pressed(), objects)
npcs = [NPC('oldlady', 100, 'people/oldlady.png', 0, 200, 200)] npc.draw(screen)
objects = [main, mobs, npcs, weapons, others]
room = Room('village', 'village', 'art/images/background/village.png', objects, WIDTH - 64, HEIGHT - 64, 0) objects[0][0].book.addspell('windslash')
freeze = True #Gameplay is freezed in certain situations objects[0][0].book.addspell('fireball')
main[0].health.health = 20 scene.update(target, objects)
scene.draw(screen)
while running:
screen.fill('#000000') else:
events = pygame.event.get() objects[0][0].book.hidden = not freeze
for event in events: objects[0][0].book.draw(screen)
if event.type == pygame.QUIT: objects[0][0].book.update()
quitGame() # flip() the display to put your work on screen
elif event.type == pygame.KEYDOWN: pygame.display.flip()
if event.key == pygame.K_e: #when book is open gameplay is freezed
freeze = not freeze clock.tick(fps) # limits FPS to 60
# RENDER YOUR GAME HERE
"""with open(background, 'r') as i: def village(screen, clock, running, background, isblack, WIDTH, HEIGHT):
bg = pygame.image.load(i) main = [herbert]
bg = pygame.transform.scale(bg, (WIDTH, HEIGHT)) mobs = []
# fill the screen with an image to clear the screen weapons = []
screen.blit(bg, (0, 0)) others = [ Obstacle('fireplace', 'interactable', 'art/images/background/fireplace.png', False, 200, 500),
""" Obstacle('house', 'Interactable', 'art/images/background/house.png', False, 500, 150, WIDTH=180, HEIGHT=160)]
if not freeze: npcs = [NPC('oldlady', 100, 'people/oldlady.png', 0, 200, 200)]
objects = room.getObjects() objects = [main, mobs, npcs, weapons, others]
screen.blit(room.background, (32, 32)) room = Room('village', 'village', 'art/images/background/village.png', objects, WIDTH - 64, HEIGHT - 64, 0)
freeze = True #Gameplay is freezed in certain situations
for thing in objects[4]: main[0].health.health = 20
thing.draw(screen)
while running:
for weapon in objects[3]: screen.fill('#000000')
weapon.update(objects) events = pygame.event.get()
weapon.draw(screen) for event in events:
if event.type == pygame.QUIT:
for thing in objects[0]: quitGame()
thing.book.hidden = not freeze elif event.type == pygame.KEYDOWN:
result = thing.update(pygame.key.get_pressed(), pygame.mouse.get_pos(), objects) if event.key == pygame.K_e: #when book is open gameplay is freezed
if result == 'village': freeze = not freeze
menu(screen, clock, running, background, isblack, WIDTH, HEIGHT) # RENDER YOUR GAME HERE
elif result == 'play': """with open(background, 'r') as i:
play(screen, clock, running, background, isblack, WIDTH, HEIGHT) bg = pygame.image.load(i)
elif result == 'house': bg = pygame.transform.scale(bg, (WIDTH, HEIGHT))
house(screen, clock, running, background, isblack, WIDTH, HEIGHT) # fill the screen with an image to clear the screen
else: screen.blit(bg, (0, 0))
thing.draw(screen) """
if not freeze:
for mob in objects[1]: objects = room.getObjects()
mob.update(objects) screen.blit(room.background, (32, 32))
mob.draw(screen)
for thing in objects[4]:
for npc in objects[2]: thing.draw(screen)
npc.update(pygame.key.get_pressed(), objects)
npc.draw(screen) for weapon in objects[3]:
weapon.update(objects)
room.update(objects) weapon.draw(screen)
else: for thing in objects[0]:
objects[0][0].book.hidden = not freeze thing.book.hidden = not freeze
objects[0][0].book.draw(screen) result = thing.update(pygame.key.get_pressed(), pygame.mouse.get_pos(), objects)
objects[0][0].book.update() if result == 'village':
# flip() the display to put your work on screen menu(screen, clock, running, background, isblack, WIDTH, HEIGHT)
pygame.display.flip() elif result == 'play':
play(screen, clock, running, background, isblack, WIDTH, HEIGHT)
clock.tick(fps) # limits FPS to elif result == 'house':
house(screen, clock, running, background, isblack, WIDTH, HEIGHT)
def house(screen, clock, running, background, isblack, WIDTH, HEIGHT): else:
main = [herbert] thing.draw(screen)
mobs = []
weapons = [] for mob in objects[1]:
others = [] mob.update(objects)
npcs = [NPC('elder', 100, 'people/reddy.png', 0, 200, 200)] mob.draw(screen)
objects = [main, mobs, npcs, weapons, others]
room = Room('house', 'house', 'art/images/background/insideHouse.png', objects, WIDTH - 64, HEIGHT - 64, 0) for npc in objects[2]:
freeze = False #Gameplay is freezed in certain situations npc.update(pygame.key.get_pressed(), objects)
npc.draw(screen)
while running:
screen.fill('#000000') room.update(objects)
events = pygame.event.get()
for event in events: else:
if event.type == pygame.QUIT: objects[0][0].book.hidden = not freeze
quitGame() objects[0][0].book.draw(screen)
elif event.type == pygame.KEYDOWN: objects[0][0].book.update()
if event.key == pygame.K_e: #when book is open gameplay is freezed # flip() the display to put your work on screen
freeze = not freeze pygame.display.flip()
# RENDER YOUR GAME HERE
"""with open(background, 'r') as i: clock.tick(fps) # limits FPS to
bg = pygame.image.load(i)
bg = pygame.transform.scale(bg, (WIDTH, HEIGHT)) def house(screen, clock, running, background, isblack, WIDTH, HEIGHT):
# fill the screen with an image to clear the screen main = [herbert]
screen.blit(bg, (0, 0)) mobs = []
""" weapons = []
if not freeze: others = []
objects = room.getObjects() npcs = [NPC('elder', 100, 'people/dorfaelteste.png', 0, 200, 200)]
screen.blit(room.background, (32, 32)) objects = [main, mobs, npcs, weapons, others]
room = Room('house', 'house', 'art/images/background/insideHouse.png', objects, WIDTH - 64, HEIGHT - 64, 0)
for thing in objects[4]: freeze = False #Gameplay is freezed in certain situations
thing.draw(screen)
while running:
# for weapon in objects[3]: screen.fill('#000000')
# weapon.update(objects) events = pygame.event.get()
# weapon.draw(screen) for event in events:
if event.type == pygame.QUIT:
for thing in objects[0]: quitGame()
thing.book.hidden = not freeze elif event.type == pygame.KEYDOWN:
result = thing.update(pygame.key.get_pressed(), pygame.mouse.get_pos(), objects) if event.key == pygame.K_e: #when book is open gameplay is freezed
if result == 'village': freeze = not freeze
menu(screen, clock, running, background, isblack, WIDTH, HEIGHT) # RENDER YOUR GAME HERE
elif result == 'play': """with open(background, 'r') as i:
play(screen, clock, running, background, isblack, WIDTH, HEIGHT) bg = pygame.image.load(i)
elif result == 'wall': bg = pygame.transform.scale(bg, (WIDTH, HEIGHT))
village(screen, clock, running, background, isblack, WIDTH, HEIGHT) # fill the screen with an image to clear the screen
else: screen.blit(bg, (0, 0))
thing.draw(screen) """
if not freeze:
for npc in objects[2]: objects = room.getObjects()
npc.update(pygame.key.get_pressed(), objects) screen.blit(room.background, (32, 32))
npc.draw(screen)
for thing in objects[4]:
objects[0][0].book.addspell('windslash') thing.draw(screen)
room.update(objects)
# for weapon in objects[3]:
else: # weapon.update(objects)
objects[0][0].book.hidden = not freeze # weapon.draw(screen)
objects[0][0].book.draw(screen)
objects[0][0].book.update() for thing in objects[0]:
# flip() the display to put your work on screen thing.book.hidden = not freeze
pygame.display.flip() result = thing.update(pygame.key.get_pressed(), pygame.mouse.get_pos(), objects)
if result == 'village':
clock.tick(fps) # limits FPS to menu(screen, clock, running, background, isblack, WIDTH, HEIGHT)
elif result == 'play':
play(screen, clock, running, background, isblack, WIDTH, HEIGHT)
elif result == 'wall':
def options(screen, clock, running, background, isblack, WIDTH, HEIGHT): village(screen, clock, running, background, isblack, WIDTH, HEIGHT)
objects = [] else:
# List that is displayed while selecting the window resolution level thing.draw(screen)
resolution = [("1920x1080", "1920x1080"),
("1920x1200", "1920x1200"), for npc in objects[2]:
("1280x720", "1280x720"), npc.update(pygame.key.get_pressed(), objects)
("2560x1440", "2560x1440"), npc.draw(screen)
("3840x2160", "3840x2160")]
objects[0][0].book.addspell('windslash')
# This function displays the currently selected options room.update(objects)
def printSettings(): else:
print("\n\n") objects[0][0].book.hidden = not freeze
# getting the data using "get_input_data" method of the Menu class objects[0][0].book.draw(screen)
settingsData = settings.get_input_data() objects[0][0].book.update()
# flip() the display to put your work on screen
for key in settingsData.keys(): pygame.display.flip()
print(f"{key}\t:\t{settingsData[key]}")
clock.tick(fps) # limits FPS to
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False def options(screen, clock, running, background, isblack, WIDTH, HEIGHT):
# RENDER YOUR GAME HERE objects = []
with open(background, 'r') as i: # List that is displayed while selecting the window resolution level
bg = pygame.image.load(i) resolution = [("1920x1080", "1920x1080"),
bg = pygame.transform.scale(bg, (WIDTH, HEIGHT)) ("1920x1200", "1920x1200"),
# fill the screen with an image to clear the screen ("1280x720", "1280x720"),
screen.blit(bg, (0, 0)) ("2560x1440", "2560x1440"),
for obj in objects: ("3840x2160", "3840x2160")]
obj.process(screen)
# This function displays the currently selected options
# flip() the display to put your work on screen
pygame.display.flip() def printSettings():
print("\n\n")
clock.tick(60) # limits FPS to 60 # getting the data using "get_input_data" method of the Menu class
settingsData = settings.get_input_data()
def menu(screen, clock, running, background, isblack, WIDTH, HEIGHT):
objects = [] for key in settingsData.keys():
objects.append(Button(WIDTH / 2 - 80, HEIGHT / 2, 160, 64, 'textbox.png', 'medieval', 48, "Play", village, attributes=[screen, clock, running, background, isblack, WIDTH, HEIGHT])) print(f"{key}\t:\t{settingsData[key]}")
#objects.append(Button(WIDTH / 2 - 80, HEIGHT / 2 - 72, 160, 64, 'textbox.png', 'medieval', 48, "Options", uwu))
objects.append(Button(WIDTH / 2 - 80, HEIGHT / 2 + 72, 160, 64, 'textbox.png', 'medieval', 48, "Exit game", quitGame)) while running:
while running: for event in pygame.event.get():
for event in pygame.event.get(): if event.type == pygame.QUIT:
if event.type == pygame.QUIT: running = False
running = False # RENDER YOUR GAME HERE
quitGame() with open(background, 'r') as i:
# RENDER YOUR GAME HERE bg = pygame.image.load(i)
with open(f'art/images/background/{background}', 'r') as i: bg = pygame.transform.scale(bg, (WIDTH, HEIGHT))
bg = pygame.image.load(i) # fill the screen with an image to clear the screen
bg = pygame.transform.scale(bg, (WIDTH, HEIGHT)) screen.blit(bg, (0, 0))
# fill the screen with an image to clear the screen for obj in objects:
screen.blit(bg, (0, 0)) obj.process(screen)
for obj in objects:
obj.update(screen) # flip() the display to put your work on screen
pygame.display.flip()
# flip() the display to put your work on screen
pygame.display.flip() clock.tick(60) # limits FPS to 60
clock.tick(60) # limits FPS to 60 def menu(screen, clock, running, background, isblack, WIDTH, HEIGHT):
objects = []
def test(screen, clock, running, background, isblack, WIDTH, HEIGHT): objects.append(Button(WIDTH / 2 - 80, HEIGHT / 2, 160, 64, 'textbox.png', 'medieval', 48, "Play", play, attributes=[screen, clock, running, background, isblack, WIDTH, HEIGHT]))
main = [MainCharacter('Herbert', 100, 'oldman.png', 500, 500, 20, 5, 1, 1, 50)] #objects.append(Button(WIDTH / 2 - 80, HEIGHT / 2 - 72, 160, 64, 'textbox.png', 'medieval', 48, "Options", uwu))
mobs = [Skeleton(i, random.randint(40, 60), 'reddy.png', random.randint(20,1000), random.randint(20,700), 5, 1, 1, 1, 200) for i in range(0,random.randint(2, 8))] objects.append(Button(WIDTH / 2 - 80, HEIGHT / 2 + 72, 160, 64, 'textbox.png', 'medieval', 48, "Exit game", quitGame))
others = [] while running:
npcs = [NPC('name', 100, 'reddy.png', 1, 200, 200)] for event in pygame.event.get():
objects = [main, mobs, npcs, others] if event.type == pygame.QUIT:
level = [] running = False
rooms = genRooms(WIDTH, HEIGHT, 'grass', objects) quitGame()
level.append(Stage('blau', 'normal', None, [], WIDTH, HEIGHT, 'blue', rooms)) # RENDER YOUR GAME HERE
freeze = False #Gameplay is freezed in certain situations with open(f'art/images/background/{background}', 'r') as i:
bg = pygame.image.load(i)
#level.append(Stage('rot', 'normal', None, [], WIDTH, HEIGHT, 'red', [ bg = pygame.transform.scale(bg, (WIDTH, HEIGHT))
# Room('red1', 'normal', 'art/images/grass.png', [], WIDTH, HEIGHT, [True, True, True, False], 0), # fill the screen with an image to clear the screen
# Room('red2', 'normal', 'art/images/grass.png', [], WIDTH, HEIGHT, [True, True, True, False], 1), screen.blit(bg, (0, 0))
# Room('red3', 'normal', 'art/images/grass.png', [], WIDTH, HEIGHT, [True, True, True, False], 2), for obj in objects:
# ])) obj.update(screen)
scene = Scene('test', 'normal', None, None, WIDTH, HEIGHT, level) # flip() the display to put your work on screen
pygame.display.flip()
# RENDER YOUR GAME HERE
while True: clock.tick(60) # limits FPS to 60
screen.fill('#000000')
events = pygame.event.get() def test(screen, clock, running, background, isblack, WIDTH, HEIGHT):
for event in events: main = [MainCharacter('Herbert', 100, 'oldman.png', 500, 500, 20, 5, 1, 1, 50)]
if event.type == pygame.QUIT: mobs = [Skeleton(i, random.randint(40, 60), 'reddy.png', random.randint(20,1000), random.randint(20,700), 5, 1, 1, 1, 200) for i in range(0,random.randint(2, 8))]
running = False others = []
quitGame() npcs = [NPC('name', 100, 'reddy.png', 1, 200, 200)]
elif event.type == pygame.KEYDOWN: objects = [main, mobs, npcs, others]
if event.key == pygame.K_e: #when book is open gameplay is freezed level = []
freeze = not freeze rooms = genRooms(WIDTH, HEIGHT, 'grass', objects)
level.append(Stage('blau', 'normal', None, [], WIDTH, HEIGHT, 'blue', rooms))
if not freeze: freeze = False #Gameplay is freezed in certain situations
objects = scene.getObjects()
for thing in objects[0]: #level.append(Stage('rot', 'normal', None, [], WIDTH, HEIGHT, 'red', [
thing.book.hidden = not freeze # Room('red1', 'normal', 'art/images/grass.png', [], WIDTH, HEIGHT, [True, True, True, False], 0),
if not thing.update(pygame.key.get_pressed(), objects): # Room('red2', 'normal', 'art/images/grass.png', [], WIDTH, HEIGHT, [True, True, True, False], 1),
menu(screen, clock, running, background, isblack, WIDTH, HEIGHT) # Room('red3', 'normal', 'art/images/grass.png', [], WIDTH, HEIGHT, [True, True, True, False], 2),
thing.draw(screen) # ]))
for mob in objects[1]: scene = Scene('test', 'normal', None, None, WIDTH, HEIGHT, level)
mob.update(objects)
mob.draw(screen) # RENDER YOUR GAME HERE
while True:
for npc in objects[2]: screen.fill('#000000')
npc.update(pygame.key.get_pressed(), objects) events = pygame.event.get()
npc.draw(screen) for event in events:
if event.type == pygame.QUIT:
for thing in objects[3]: running = False
thing.update(objects) quitGame()
thing.draw(screen) elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_e: #when book is open gameplay is freezed
else: freeze = not freeze
objects[0][0].book.hidden = not freeze
objects[0][0].book.draw(screen) if not freeze:
objects[0][0].book.update() objects = scene.getObjects()
# flip() the display to put your work on screen for thing in objects[0]:
pygame.display.flip() thing.book.hidden = not freeze
if not thing.update(pygame.key.get_pressed(), objects):
clock.tick(60) # limits FPS to 60 menu(screen, clock, running, background, isblack, WIDTH, HEIGHT)
thing.draw(screen)
def main():
config = readConfig() for mob in objects[1]:
screen, clock, running, isblack, background, objects = setUp(config["screen"]) mob.update(objects)
WIDTH, HEIGHT = screen.get_size() mob.draw(screen)
#objects.append(Button(WIDTH / 2 - 80, HEIGHT / 2 - 72, 160, 64, 'textbox.png', 'medieval', 48, "Play", play))
#objects.append(Button(WIDTH / 2 - 80, HEIGHT / 2, 160, 64, 'textbox.png', 'medieval', 48, "Options", uwu)) for npc in objects[2]:
#objects.append(Button(WIDTH / 2 - 80, HEIGHT / 2 + 72, 160, 64, 'textbox.png', 'medieval', 48, "Exit game", quitGame)) npc.update(pygame.key.get_pressed(), objects)
menu(screen, clock, running, background, isblack, WIDTH, HEIGHT) npc.draw(screen)
test(screen, clock, running, background, isblack, WIDTH, HEIGHT)
for thing in objects[3]:
"""while running: thing.update(objects)
for event in pygame.event.get(): thing.draw(screen)
if event.type == pygame.QUIT:
running = False else:
#menu(screen, clock, running, background, isblack, WIDTH, HEIGHT) objects[0][0].book.hidden = not freeze
if not isblack: objects[0][0].book.draw(screen)
with open(background, 'r') as i: objects[0][0].book.update()
bg = pygame.image.load(i) # flip() the display to put your work on screen
bg = pygame.transform.scale(bg, (WIDTH, HEIGHT)) pygame.display.flip()
# fill the screen with a color to wipe away anything from last frame
screen.blit(bg, (0, 0)) clock.tick(60) # limits FPS to 60
# RENDER YOUR GAME HERE def main():
config = readConfig()
else: screen, clock, running, isblack, background, objects = setUp(config["screen"])
for obj in objects: WIDTH, HEIGHT = screen.get_size()
obj.process(screen, clock, running, background, isblack, WIDTH, HEIGHT) #objects.append(Button(WIDTH / 2 - 80, HEIGHT / 2 - 72, 160, 64, 'textbox.png', 'medieval', 48, "Play", play))
# flip() the display to put your work on screen #objects.append(Button(WIDTH / 2 - 80, HEIGHT / 2, 160, 64, 'textbox.png', 'medieval', 48, "Options", uwu))
pygame.display.flip() #objects.append(Button(WIDTH / 2 - 80, HEIGHT / 2 + 72, 160, 64, 'textbox.png', 'medieval', 48, "Exit game", quitGame))
menu(screen, clock, running, background, isblack, WIDTH, HEIGHT)
clock.tick(60) # limits FPS to 60""" #test(screen, clock, running, background, isblack, WIDTH, HEIGHT)
pygame.quit() """while running:
for event in pygame.event.get():
if __name__ == '__main__': if event.type == pygame.QUIT:
herbert = MainCharacter('Herbert', 100, 'people/oldman.png', 500, 500, 20, 5, 1, 1, 50) running = False
main() #menu(screen, clock, running, background, isblack, WIDTH, HEIGHT)
if not isblack:
with open(background, 'r') as i:
bg = pygame.image.load(i)
bg = pygame.transform.scale(bg, (WIDTH, HEIGHT))
# fill the screen with a color to wipe away anything from last frame
screen.blit(bg, (0, 0))
# RENDER YOUR GAME HERE
else:
for obj in objects:
obj.process(screen, clock, running, background, isblack, WIDTH, HEIGHT)
# flip() the display to put your work on screen
pygame.display.flip()
clock.tick(60) # limits FPS to 60"""
pygame.quit()
if __name__ == '__main__':
herbert = MainCharacter('Herbert', 100, 'people/oldman.png', 500, 500, 20, 5, 1, 1, 50)
main()

656
viecher.py
View file

@ -1,656 +0,0 @@
import pygame as pg
from classes import *
from main import *
import random
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.transform.scale2x(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)
pg.draw.rect(screen, '#ef0120', self.rect, 2)
class NPC(Objects):
def __init__(self, name, ms, sprite, convo_scene, x, y) -> None:
super().__init__(name, ms, sprite, x, y)
self.talking = False
self.hidden = False
self.conversation = Convo(self, convo_scene)
self.lastUpdate = pg.time.get_ticks()
def talk(self, objects):
self.talking = True
objects[0][0].talking = True
def draw(self, screen):
super().draw(screen)
if self.talking:
self.conversation.draw(screen)
def update(self, keys, objects):
if self.name == 'oldlady':
if self.conversation.convo_scene==0 and 'rat' in objects[0][0].killed and objects[1]==[]:
self.conversation.convo_scene=1
if self.lastUpdate + 200 < pg.time.get_ticks():
if self.talking:
self.conversation.update(keys, objects)
self.lastUpdate = pg.time.get_ticks()
else:
touches = pg.sprite.spritecollideany(self, objects[0])
if touches is not None and keys[pg.K_f] and isinstance(touches, MainCharacter):
self.talk(objects)
self.lastUpdate = pg.time.get_ticks()
class Convo(Label):
def __init__(self, npc, convo_scene, text='', x = 140, y = 600, width = 1000, height = 100, font='simple', font_size = 20) -> None:
super().__init__(x, y, width, height, text, font, font_size)
self.convo_act=0
self.npc = npc
self.convo_scene = convo_scene
self.convos = [
['oldlady', 0, ['There are so many rats here.', 'I wish someone would to something against that.','An experienced fighter could kill them.', 'For them it only takes a mouseclick.']],
['oldlady', 1, ['Oh, did you kill all the rats?', 'You must be the chosen one!', 'It would be nice if you would go and talk to the village elder.']],
['elder', 0, ['Who are you?', 'You want to help us?', 'We have a serious problem with monsters.', 'One day they appeared out of nowhere and started attacking.', 'When you jump into the portal over there,', 'You will be send to a place with monsters.', 'PLEASE help us!']],
['elder', 1, ['Who are you?', 'You want to help us?', 'We have a serious problem with monsters.', 'One day they appeared out of nowhere and started attacking.', 'When you jump into the portal over there,', 'You will be send to a place with monsters.', 'PLEASE help us!']]
]
def draw(self, screen):
self.text = self.findConversation()[2][self.convo_act]
super().draw(screen)
def findConversation(self):
for convo in self.convos:
if convo[0] == self.npc.name and convo[1] == self.convo_scene:
return convo
return ['ERROR']
def update(self, keys, objects):
if keys[pg.K_f]:
convo = self.findConversation()
if self.convo_act+1 < len(convo[2]):
self.text = convo[2][self.convo_act]
self.convo_act += 1
else:
if convo[0] == 'oldlady':
if convo[1] == 0:
for i in range(0,5):
objects[1].append(Rat('rat', random.randint(150,250), 800, 400+i*20, 1, 1, 1, 100, 25))
elif convo[1] == 1:
objects[0][0].level.level = 5
while 'rat' in objects[0][0].killed: objects[0][0].killed.remove('rat')
if convo[0] == 'elder':
if convo[1] == 0:
objects[4].append(Obstacle('portal', 'interactable', 'art/images/background/portal.png', False, 700, 300))
self.convo_scene += 1
self.convo_act = 0
self.npc.talking = False
objects[0][0].talking = False
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 = 0
class MainCharacter(Fighter):
def __init__(self, name, ms, sprite, x, y, health, damage, level, asp, atr, killed=[]) -> None:
super().__init__(name, ms, sprite, x, y, health, damage, level, asp, atr)
self.book = Book(0, 0, [], None, None)
self.talking = False
self.level = Level(1000, 38, 150, 40, level, 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, hurtCooldown=self.hurtCooldown)
self.thinks = Thinks(self.x + 20, self.y - 50, 150, 100, 'brr I\'m freezing')
self.freezing = True
self.killed = killed # amount of mobs that were killed
self.load_frames(f'art/images/people/oldmanwalk.png', f'art/images/people/oldmanattack.png')
self.current_frame = 0
self.animation_speed = 0.1
self.last_frame_update = pg.time.get_ticks()
self.rect = pg.Rect(x, y, self.walk_frames[0].get_width(), self.walk_frames[0].get_height())
self.is_attacking = False
def load_frames(self, walk_sprite_sheet, attack_sprite_sheet):
self.walk_frames = self.load_animation_frames(walk_sprite_sheet, frame_width=40, frame_height=64)
self.attack_frames = self.load_animation_frames(attack_sprite_sheet, frame_width=66, frame_height=64) # Adjust frame width and height as needed
def load_animation_frames(self, sprite_sheet, frame_width, frame_height):
sprite_sheet = pg.transform.scale2x(pg.image.load(sprite_sheet))
animation_frames = []
if frame_width == 40:
frames_coordinates = [
(frame_width, 0),
(frame_width*2, 0),
(frame_width*3, 0),
(frame_width*4, 0),
(frame_width*5, 0),
(frame_width*6, 0),
(frame_width*7, 0),
(frame_width*8, 0),
]
else:
frames_coordinates = [
(frame_width, 0),
(frame_width*2, 0),
(frame_width*3, 0),
(frame_width*4, 0),
(frame_width*5, 0),
(frame_width*6, 0)
]
for x, y in frames_coordinates:
frame = pg.Surface((frame_width, frame_height), pg.SRCALPHA)
frame.blit(sprite_sheet, (0, 0), (x, y, frame_width, frame_height))
animation_frames.append(frame)
return animation_frames
def draw(self, screen):
if self.hidden:
return
current_time = pg.time.get_ticks()
if self.is_attacking:
animation_frames = self.attack_frames
else:
animation_frames = self.walk_frames
if current_time - self.last_frame_update > self.animation_speed * 1000:
self.current_frame = (self.current_frame + 1) % len(animation_frames)
self.last_frame_update = current_time
current_frame_image = animation_frames[self.current_frame]
screen.blit(current_frame_image, (self.x, self.y))
self.rect.x, self.rect.y = self.x, self.y
self.health.draw(screen)
self.level.draw(screen)
self.book.draw(screen)
pg.draw.rect(screen, '#e900fa', self.rect, 2)
if self.thinks.hidden == False:
self.thinks.draw(screen, self.x + 20, self.y - 100)
def hurt(self, damage, objects):
if not self.talking:
self.health.hurt(damage)
def obstacle_interaction(self, objects):
touches = pg.sprite.spritecollideany(self, objects[4])
if touches is not None:
if touches.name == 'fireplace':
self.freezing = False
elif touches.name == 'portal' and self.level.level != 1:
return 'play'
elif touches.name == 'house' and self.level.level != 1:
self.x = 500
self.y = 400
return 'house'
elif 'wall' in touches.name:
return 'wall'
else:
return True
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[2] + objects[4])
if touches is not None and not isinstance(touches, Weapons):
if isinstance(touches, Obstacle):
if not touches.collision:
# print(touches.name)
return
if touches.type == 'wall':
if touches.name == 'wall_l':
self.x += (2 + (self.x - touches.rect.x))
elif touches.name == 'wall_r':
self.x -= (2 + self.rect.width - (touches.rect.x - self.x))
if touches.name == 'wall_t':
self.y += (2 + (self.y - touches.rect.y))
elif touches.name == 'wall_b':
self.y -= (2 + self.rect.height - (touches.rect.y - self.y))
return
elif isinstance(touches, NPC):
return
if self.x <= touches.rect.x: self.x -= (self.rect.width - (touches.rect.x - self.x))
elif self.x > touches.rect.x: self.x += (self.rect.width - (self.x - touches.rect.x - touches.rect.width * 0.66))
#if self.y <= touches.y: pass
#elif self.y > touches.y: pass
#self.x -= moveto[0] * 2 / fps
#self.y -= moveto[1] * 2 / fps
"""
if self.x <= 32:
self.x = 33
elif self.x >= objects[3][0].width - 32:
self.x = objects[3][0].width - 32 - self.rect.width + 1
if self.y <= 32:
self.y = 33
elif self.y >= objects[3][0].height - 32:
self.y = objects[3][0].height - 32 - self.rect.height + 1
"""
def attack(self, obj, mouse):
if self.lastAttack + self.attack_speed * 1000 < pg.time.get_ticks():
moveto = mouse - vec(self.x, self.y)
if self.book.current_sp == 'fireball':
weapon = Fireball('fb1', 100, self.x, self.y, moveto, 5)
elif self.book.current_sp == 'windslash':
weapon = Windslash('ws1', 100, self.x, self.y, moveto, 10)
else:
weapon = Punch('punch', 100, self.x, self.y, moveto, 1, Mobs, life_ticks=500)
obj[3].append(weapon)
self.lastAttack = pg.time.get_ticks()
if not self.is_attacking:
self.current_frame = 0
self.is_attacking = True
def update(self, keys, mouse, objects):
if not self.talking:
is_moving = False
if keys[pg.K_w] or keys[pg.K_UP] or keys[pg.K_a] or keys[pg.K_LEFT] or keys[pg.K_s] or keys[pg.K_DOWN] or keys[pg.K_d] or keys[pg.K_RIGHT]:
is_moving = True
if is_moving:
self.walk(keys, objects)
self.is_attacking = False
else:
current_time = pg.time.get_ticks()
if current_time - self.last_frame_update > self.animation_speed * 1000:
self.current_frame = (self.current_frame + 1) % len(self.walk_frames)
self.last_frame_update = current_time
if not self.is_attacking:
self.current_frame = 0
if pg.mouse.get_pressed()[0]:
self.attack(objects, vec(mouse))
if self.is_attacking:
if self.current_frame == len(self.attack_frames) - 1:
self.is_attacking = False
self.current_frame = 0
self.thinks.update(objects, self)
if self.health.health <= 0:
return 'village'
else:
return self.obstacle_interaction(objects)
class Hearts():
def __init__(self, health, sprite, x, y, hurtCooldown) -> None:
self.x = x
self.y = y
self.health = health
self.lastHurt = pg.time.get_ticks()
self.hurtCooldown = hurtCooldown
self.hidden = False
self.sprite=[]
for parts in sprite:
with open(f'art/images/main_attributes/{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/main_attributes/{parts}') as i:
self.sprite.append(pg.image.load(i))
class Level(Label):
def __init__(self, x, y, width, height, level, text, font='simple', font_size=20, font_color='#1e90ff', sprite='label.png') -> None:
super().__init__(x, y, width, height, text, font, font_size, font_color, sprite)
self.level = level
def draw(self, screen):
self.text = f'will to live: {self.level}%'
super().draw(screen)
class Thinks(Label):
def __init__(self, x, y, width, height, text, font='simple', font_size=15, font_color='#000000', sprite='thinks.png') -> None:
super().__init__(x, y, width, height, text, font, font_size, font_color, sprite)
self.scene = 0
def draw(self, screen, x, y):
if self.hidden:
return
self.x = x
self.y = y
super().draw(screen)
def update(self, objects, main):
if not self.hidden:
if self.scene == 0 and not main.freezing:
self.scene = 1
self.hidden = True
elif self.scene == 1 and main.talking:
self.scene = 2
self.hidden = True
if self.scene == 1:
touches = pg.sprite.spritecollideany(main, objects[2])
if touches is not None and isinstance(touches, NPC):
self.text = 'I should press \"f\"'
self.hidden = False
else:
self.hidden = False
self.text = 'the lady over there'
class Book():
def __init__(self, x, y, spells, current_spell, current_shield) -> None:
with open(f'art/images/main_attributes/book.png') as i:
self.sprite = pg.image.load(i)
self.sprite = pg.transform.scale(self.sprite, (1280, 720))
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())
self.sp_list = spells
self.current_sp = current_spell
self.text_left = ["Dear User, ", "in case you fell on the ground too hard,", "here is a quick reminder:",
"You are a homeless person. One cold day","you went to the library to warm up yourself.",
"There you got bored and found and opened me.", "This lead to you being thrown into this world.",
"But you can find a way out of here again."]
self.text_right = ["This book will help you to survive.", "You can open and close me when pressing e.",
"Click on a picture to choose your spell.",
"Talk to fairies to unlock new spells!"]
self.buttons=[]
self.buttons_y = 400
self.buttons_x = 800
def draw(self, screen):
if self.hidden:
return
self.rect.x, self.rect.y = self.x, self.y
screen.blit(self.sprite, self.rect)
text_left_y = 100
text_right_y = 100
for text in self.text_left:
label = Label(100, text_left_y, 500, 50, text, font_color='#000000', sprite='empty.png')
label.draw(screen)
text_left_y += 50
for text in self.text_right:
label = Label(680, text_right_y, 500, 50, text, font_color='#000000', sprite='empty.png')
label.draw(screen)
text_right_y += 50
for button in self.buttons:
button.update(screen)
def addspell(self, spell):
if spell not in self.sp_list:
self.sp_list.append(spell)
self.current_sp = spell
self.buttons.append(Button(self.buttons_x, self.buttons_y, 58, 50, f'{spell}_icon.png', 'medieval', 23, attributes=[spell], onclickFunction=self.update_spell))
self.buttons_y += 100
def update_spell(self, spell):
self.current_sp = spell
def update(self):
pass
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)
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
touches = pg.sprite.spritecollideany(self, obj[4])
if touches is not None and not isinstance(touches, Weapons):
if isinstance(touches, Obstacle):
if not touches.collision:
return
if touches.type == 'wall':
if touches.name == 'wall_l':
self.x += (2 + (self.x - touches.rect.x))
elif touches.name == 'wall_r':
self.x -= (2 + self.rect.width - (touches.rect.x - self.x))
if touches.name == 'wall_t':
self.y += (2 + (self.y - touches.rect.y))
elif touches.name == 'wall_b':
self.y -= (2 + self.rect.height - (touches.rect.y - self.y))
if self.x <= touches.rect.x: self.x -= (self.rect.width - (touches.rect.x - self.x))
elif self.x > touches.rect.x: self.x += (self.rect.width - (self.x - touches.rect.x - touches.rect.width * 0.66))
else:
self.attack(moveto, obj)
def hurt(self, damage, objects):
self.health -= damage
if self.health <= 0:
objects[0][0].killed.append(self.name)
self.hidden = True
objects[1].remove(self)
def update(self, obj):
self.chase(obj)
class Skeleton(Mobs):
def __init__(self, name, ms, x, y, health, damage, level, asp, atr, sprite = 'people/skeleton.png', drops=0) -> None:
super().__init__(name, ms, sprite, x, y, health, damage, level, asp, atr, drops)
def attack(self, moveto, obj):
if self.lastAttack + self.attack_speed * 1000 < pg.time.get_ticks():
obj[3].append(Arrow("arrow", 200, self.x, self.y, moveto, self.damage))
self.lastAttack = pg.time.get_ticks()
class Zombie(Mobs):
def __init__(self, name, ms, x, y, health, damage, level, asp, atr, sprite_sheet='people/zombiewalk.png', drops=0) -> None:
super().__init__(name, ms, sprite_sheet, x, y, health, damage, level, asp, atr, drops)
self.load_frames(f'art/images/{sprite_sheet}')
self.current_frame = 0
self.animation_speed = 250
self.last_frame_update = pg.time.get_ticks()
self.hidden = False
self.rect = pg.Rect(x, y, 40, 64)
def load_frames(self, sprite_sheet):
sprite_sheet = pg.transform.scale2x(pg.image.load(sprite_sheet).convert_alpha())
frame_width = 40
frame_height = 64
frames_coordinates = [(40, 0),(80, 0),(120, 0),(160, 0),(200, 0),(240, 0),(280, 0), (320, 0)]
self.animation_frames = []
for x, y in frames_coordinates:
frame = pg.Surface((frame_width, frame_height), pg.SRCALPHA)
frame.blit(sprite_sheet, (0, 0), (x, y, frame_width, frame_height))
self.animation_frames.append(frame)
def draw(self, screen):
if self.hidden:
return
current_time = pg.time.get_ticks()
if current_time - self.last_frame_update > self.animation_speed:
self.current_frame = (self.current_frame + 1) % len(self.animation_frames)
self.last_frame_update = current_time
current_frame_image = self.animation_frames[self.current_frame]
screen.blit(current_frame_image, (self.x, self.y))
self.rect.topleft = (self.x, self.y)
pg.draw.rect(screen, '#ef0120', self.rect, 2)
def attack(self, moveto, obj):
if self.lastAttack + self.attack_speed * 1000 < pg.time.get_ticks():
obj[3].append(Punch('punch', 100, self.x, self.y, moveto, self.damage))
self.lastAttack = pg.time.get_ticks()
class Rat(Mobs):
def __init__(self, name, ms, x, y, health, damage, level, asp, atr, sprite='people/rat.png', drops=0) -> None:
super().__init__(name, ms, sprite, x, y, health, damage, level, asp, atr, drops)
def attack(self, moveto, obj):
if self.lastAttack + self.attack_speed * 1000 < pg.time.get_ticks():
obj[3].append(Punch('punch', 100, self.x, self.y, moveto, self.damage, MainCharacter))
self.lastAttack = pg.time.get_ticks()
class Weapons(Objects):
def __init__(self, name, ms, sprite, x, y, moveto, damage, life_ticks) -> None:
super().__init__(name, ms, sprite, x, y)
self.moveto = moveto
self.damage = damage
self.life_ticks= life_ticks
self.spawn_tick = pg.time.get_ticks()
pos = vec(1,0)
angle = pos.angle_to(moveto)
self.sprite = pg.transform.rotate(self.sprite, -angle)
def die(self, objects, kills):
touches = pg.sprite.spritecollideany(self, objects[0] + objects[1])
if touches is not None and isinstance(touches, kills):
touches.hurt(self.damage, objects)
self.hidden = True
if self in objects[3]:
objects[3].remove(self)
def move(self, objects):
self.moveto.scale_to_length(self.speed)
self.x += self.moveto[0] / fps
self.y += self.moveto[1] / fps
if pg.time.get_ticks() - self.spawn_tick > self.life_ticks:
self.hidden = True
objects[3].remove(self)
class Spells(Weapons):
def __init__(self, name, ms, sprite, x, y, moveto, damage, life_ticks) -> None:
super().__init__(name, ms, sprite, x, y, moveto, damage, life_ticks)
class Fireball(Spells):
def __init__(self, name, ms, x, y, moveto, damage, sprite = 'weapons/fireball.png', life_ticks=5000) -> None:
super().__init__(name, ms, sprite, x, y, moveto, damage, life_ticks)
def update(self, objects):
self.move(objects)
self.die(objects, Mobs)
class Windslash(Spells):
def __init__(self, name, ms, x, y, moveto, damage, sprite = 'weapons/windslash.png', life_ticks=1000) -> None:
super().__init__(name, ms, sprite, x, y, moveto, damage, life_ticks)
def update(self, objects):
self.move(objects)
self.die(objects, Mobs)
def move(self, objects):
super().move(objects)
self.moveto = self.moveto.rotate(5)
class Arrow(Weapons):
def __init__(self, name, ms, x, y, moveto, damage, sprite = 'weapons/arrow.png', life_ticks=5000) -> None:
super().__init__(name, ms, sprite, x, y, moveto, damage, life_ticks)
def update(self, objects):
self.move(objects)
self.die(objects, MainCharacter)
class Punch(Weapons):
def __init__(self, name, ms, x, y, moveto, damage, kills, sprite = 'weapons/empty.png', life_ticks=100) -> None:
super().__init__(name, ms, sprite, x, y, moveto, damage, life_ticks)
self.kills = kills
def update(self, objects):
self.move(objects)
self.die(objects, self.kills)