528 lines
17 KiB
Python
528 lines
17 KiB
Python
import pygame
|
|
import sys
|
|
import time
|
|
import random
|
|
import math
|
|
import copy
|
|
from pygame.locals import *
|
|
|
|
pygame.init()
|
|
|
|
|
|
# has attributes for basic thing in game
|
|
class Game:
|
|
def __init__(self, game_maps=None):
|
|
self.alive = True
|
|
# fs = fullscreen
|
|
self.fs = False
|
|
self.custom_id_giver = 0
|
|
|
|
self.game_flow = {}
|
|
|
|
self.game_maps = None
|
|
# checks if there are any maps if there are puts them in self.game_maps
|
|
if game_maps is not None:
|
|
self.game_maps = game_maps
|
|
|
|
|
|
# stores objects in a sorted way
|
|
class Objects:
|
|
def __init__(self):
|
|
self.game_objects = []
|
|
self.collision_objects = []
|
|
self.moving_objects = []
|
|
|
|
# dunno if next att will be useful
|
|
# u add ids of objects u want to delete there is no func to delete for now
|
|
|
|
self.objects_to_delete = []
|
|
|
|
self.values = {
|
|
"pos_to_del": []
|
|
}
|
|
|
|
def do_collisions(self, objects):
|
|
for obj in self.collision_objects:
|
|
collision(obj, objects)
|
|
|
|
def take_out_trash(self, ids):
|
|
for trash in self.objects_to_delete:
|
|
ids.ids_to_remove.append(trash)
|
|
self.objects_to_delete = []
|
|
|
|
|
|
# Id class just stores all ids of all objects
|
|
class Id:
|
|
all_ids = []
|
|
ids_to_remove = []
|
|
|
|
def remove_by_id(self, objects):
|
|
for item in self.ids_to_remove:
|
|
for obj in objects.game_objects:
|
|
if obj.object_id == item:
|
|
g_index = objects.game_objects.index(obj)
|
|
if obj.moving:
|
|
m_index = objects.moving_objects.index(obj)
|
|
if obj.move.collisions:
|
|
c_index = objects.collision_objects.index(obj)
|
|
|
|
del objects.collision_objects[c_index]
|
|
|
|
del objects.moving_objects[m_index]
|
|
|
|
del objects.game_objects[g_index]
|
|
|
|
self.ids_to_remove = []
|
|
|
|
|
|
class Scroll:
|
|
def __init__(self, scroll):
|
|
self.scroll = scroll
|
|
self.fade = 20
|
|
self.safe_fade = 20
|
|
self.in_progress = False
|
|
self.save_scroll = self.scroll
|
|
|
|
def move_scroll(self, player, screen, which, space=20):
|
|
if which == "y" or which == "both":
|
|
self.scroll[1] += (player.rect.y - self.scroll[1] - (screen[1] / 2) + (player.size[1] / 2)) / space
|
|
self.scroll[1] = int(self.scroll[1])
|
|
if which == "x" or which == "both":
|
|
self.scroll[0] += (player.rect.x - self.scroll[0] - (screen[0] / 2) + (player.size[0] / 2)) / space
|
|
self.scroll[0] = int(self.scroll[0])
|
|
|
|
def add_scroll(self, which, how_much, fade=None):
|
|
if fade is not None:
|
|
self.safe_fade = fade
|
|
if self.in_progress is False:
|
|
self.load_safe_fade()
|
|
self.save_scroll = self.scroll
|
|
self.in_progress = True
|
|
how_much[0] /= self.fade
|
|
how_much[1] /= self.fade
|
|
self.fade += 0.01 * self.fade
|
|
|
|
if which == "x" or which == "both":
|
|
self.scroll[0] += how_much[0]
|
|
self.scroll[0] = round(self.scroll[0])
|
|
|
|
if which == "y" or which == "both":
|
|
self.scroll[1] += how_much[1]
|
|
self.scroll[1] = round(self.scroll[1])
|
|
|
|
def load_safe_fade(self):
|
|
self.fade = self.safe_fade
|
|
self.in_progress = False
|
|
|
|
# next function is used for mouse scrolling mainly
|
|
def move_scroll_based_on_pos(self, pos, screen, which, space=20):
|
|
# id used for mouse u can first check mouse pos from mid to create non moving bubble in middle
|
|
if which == "y" or which == "both":
|
|
self.scroll[1] += (pos[1] - self.scroll[1] - (screen[1] / 2)) / space
|
|
self.scroll[1] = int(self.scroll[1])
|
|
if which == "x" or which == "both":
|
|
self.scroll[0] += (pos[0] - self.scroll[0] - (screen[0] / 2)) / space
|
|
self.scroll[0] = int(self.scroll[0])
|
|
|
|
# for limiting scroll
|
|
@staticmethod
|
|
def scroll_lim(scroll, lim_min, lim_max):
|
|
# min lim has priority
|
|
|
|
if lim_min[0] < lim_max[0]:
|
|
|
|
if scroll.scroll[0] < lim_min[0]:
|
|
scroll.scroll[0] = lim_min[0]
|
|
|
|
if scroll.scroll[0] > lim_max[0]:
|
|
scroll.scroll[0] = lim_max[0]
|
|
else:
|
|
scroll.scroll[0] = lim_min[0]
|
|
|
|
if lim_min[1] < lim_max[1]:
|
|
if scroll.scroll[1] < lim_min[1]:
|
|
scroll.scroll[1] = lim_min[1]
|
|
|
|
if scroll.scroll[1] > lim_max[1]:
|
|
scroll.scroll[1] = lim_max[1]
|
|
else:
|
|
scroll.scroll[1] = lim_min[1]
|
|
|
|
|
|
class Special:
|
|
def __init__(self, object_id):
|
|
self.object_id = object_id
|
|
self.stage = ""
|
|
self.attribute = ""
|
|
self.images = []
|
|
self.attribute_0 = 0
|
|
self.attribute_1 = 0
|
|
self.attribute_2 = 0
|
|
self.color_r = [0, 0, 0]
|
|
self.boolean_attribute = False
|
|
self.height = 0
|
|
self.power = 0
|
|
self.flip = False
|
|
self.scroll = False
|
|
self.fixed = False
|
|
|
|
|
|
# collisions class take care of collision funcs
|
|
# !!!!!!!!!! holds init for Object !!!!!!!!!!!!!!!!!!!
|
|
# class purely for inheritance
|
|
class Collisions(Id):
|
|
|
|
def __init__(self, typeX, object_id, x_y, movement, direction, moving, size, special=None):
|
|
self.type = typeX
|
|
self.object_id = object_id
|
|
self.object_pos = x_y
|
|
self.movement = movement
|
|
self.direction = direction
|
|
self.moving = moving
|
|
self.size = size
|
|
self.dir_movement = [0.0, 0.0]
|
|
self.memory = []
|
|
self.special = special
|
|
if self.object_id != self.all_ids:
|
|
self.all_ids.append(self.object_id)
|
|
else:
|
|
print("duplicate/ linked object")
|
|
|
|
# giving it bonus classes
|
|
|
|
if self.moving:
|
|
self.move = Moving_Object()
|
|
if self.special:
|
|
self.specific = Special(self.object_id)
|
|
|
|
self.rect = pygame.Rect(self.object_pos[0], self.object_pos[1], self.size[0], self.size[1])
|
|
|
|
# theres a function for every type of collisions
|
|
# edit collisions here (I added some basic ones just so u can see)
|
|
# self if objects that it hit and obj is the object that hit smt
|
|
|
|
# always add both side of collisions (ask who collided with whom)
|
|
|
|
def hit_bottom(self, obj, objects):
|
|
if self.type == "solid":
|
|
if obj.type == "player":
|
|
obj.rect.bottom = self.rect.top
|
|
obj.object_pos = [obj.rect.x, obj.rect.y]
|
|
self.memory[0] -= 1
|
|
if self.memory[0] == 0:
|
|
objects.objects_to_delete.append(self.object_id)
|
|
|
|
opposite = obj.move.get_final_vector()
|
|
opp = [-opposite[0] * 0.4, -opposite[1] * 0.8]
|
|
obj.move.vectors.append(opp)
|
|
|
|
def hit_top(self, obj, objects):
|
|
if self.type == "solid":
|
|
if obj.type == "player":
|
|
obj.rect.top = self.rect.bottom
|
|
obj.object_pos = [obj.rect.x, obj.rect.y]
|
|
self.memory[0] -= 1
|
|
if self.memory[0] == 0:
|
|
objects.objects_to_delete.append(self.object_id)
|
|
|
|
opposite = obj.move.get_final_vector()
|
|
opp = [-opposite[0] * 0.4, -opposite[1] * 0.8]
|
|
obj.move.vectors.append(opp)
|
|
|
|
def hit_left(self, obj, objects):
|
|
if self.type == "solid":
|
|
if obj.type == "player":
|
|
obj.rect.left = self.rect.right
|
|
obj.object_pos = [obj.rect.x, obj.rect.y]
|
|
self.memory[0] -= 1
|
|
if self.memory[0] == 0:
|
|
objects.objects_to_delete.append(self.object_id)
|
|
|
|
opposite = obj.move.get_final_vector()
|
|
opp = [-opposite[0] * 0.4, -opposite[1] * 0.8]
|
|
obj.move.vectors.append(opp)
|
|
|
|
def hit_right(self, obj, objects):
|
|
if self.type == "solid":
|
|
if obj.type == "player":
|
|
obj.rect.right = self.rect.left
|
|
obj.object_pos = [obj.rect.x, obj.rect.y]
|
|
self.memory[0] -= 1
|
|
if self.memory[0] == 0:
|
|
objects.objects_to_delete.append(self.object_id)
|
|
|
|
opposite = obj.move.get_final_vector()
|
|
opp = [-opposite[0] * 0.4, -opposite[1] * 0.8]
|
|
obj.move.vectors.append(opp)
|
|
|
|
|
|
# next 2 classes are for object class
|
|
class Moving_Object:
|
|
def __init__(self):
|
|
# consts
|
|
self.degree = 0.0174533
|
|
self.pi = math.pi
|
|
self.half_pi = round(math.pi / 2, 6)
|
|
self.two_pi = round(math.pi * 2, 6)
|
|
self.three_halves_pi = round(3 * (math.pi / 2), 6)
|
|
self.speed = 1
|
|
self.force = 3
|
|
self.offset = 0
|
|
self.vectors = []
|
|
|
|
self.forward = False
|
|
self.backwards = False
|
|
self.left = False
|
|
self.right = False
|
|
|
|
self.collisions = False
|
|
|
|
def move(self, dir_movement):
|
|
|
|
movement = dir_movement
|
|
|
|
return movement
|
|
|
|
# dir is the angle the player is facing
|
|
def change_dir(self, direction, angle):
|
|
|
|
new_vector = [0, 0]
|
|
|
|
if self.left:
|
|
direction -= angle
|
|
if direction < 0:
|
|
direction += self.two_pi
|
|
new_vector[0] = round(math.cos(direction) * self.speed, 2)
|
|
new_vector[1] = round(math.sin(direction) * self.speed, 2)
|
|
self.vectors.append(new_vector)
|
|
elif self.right:
|
|
direction += angle
|
|
if direction > self.two_pi:
|
|
direction -= self.two_pi
|
|
new_vector[0] = round(math.cos(direction) * self.speed, 2)
|
|
new_vector[1] = round(math.sin(direction) * self.speed, 2)
|
|
self.vectors.append(new_vector)
|
|
elif self.forward:
|
|
new_vector[0] = round(math.cos(direction) * self.speed, 2)
|
|
new_vector[1] = round(math.sin(direction) * self.speed, 2)
|
|
self.vectors.append(new_vector)
|
|
|
|
return direction, self.get_final_vector()
|
|
|
|
# used for setting things before game loop
|
|
def set_start_dir_movement(self, direction, dir_movement):
|
|
dir_movement[0] = round(math.cos(direction + (self.offset * self.degree)) * self.speed, 2)
|
|
dir_movement[1] = round(math.sin(direction + (self.offset * self.degree)) * self.speed, 2)
|
|
return dir_movement
|
|
|
|
def get_final_vector(self):
|
|
to_remove = []
|
|
for i in range(len(self.vectors)-1):
|
|
self.vectors[i][0] *= 0.96
|
|
self.vectors[i][1] *= 0.96
|
|
if abs(self.vectors[i][0]) < 0.2 and abs(self.vectors[i][1]) < 0.2:
|
|
to_remove.append(self.vectors[i])
|
|
|
|
for item in to_remove:
|
|
self.vectors.remove(item)
|
|
|
|
final_vector = [0, 0]
|
|
|
|
for vector in self.vectors:
|
|
final_vector[0] += vector[0]
|
|
final_vector[1] += vector[1]
|
|
|
|
return final_vector
|
|
|
|
|
|
class Object(Collisions):
|
|
def __init__(self, typeX, object_id, x_y, movement, direction, moving, size, special=None):
|
|
super().__init__(typeX, object_id, x_y, movement, direction, moving, size, special)
|
|
|
|
def __str__(self):
|
|
return self.type
|
|
|
|
# changes position along with the rect
|
|
def change_pos(self, x_y):
|
|
self.object_pos = x_y
|
|
self.rect = pygame.Rect(self.object_pos[0], self.object_pos[1], self.size[0], self.size[1])
|
|
|
|
|
|
class Mouse:
|
|
|
|
points = 0
|
|
|
|
def __init__(self, mouse_pos):
|
|
self.mouse_pos = mouse_pos
|
|
self.mouse_scroll = [0, 0]
|
|
|
|
def update(self, Win_size, Default_size):
|
|
self.mouse_pos = pygame.mouse.get_pos()
|
|
self.mouse_pos = [((self.mouse_pos[0] - self.mouse_scroll[0]) * (Default_size[0] / Win_size[0])),
|
|
((self.mouse_pos[1] - self.mouse_scroll[1]) * (Default_size[1] / Win_size[1]))]
|
|
|
|
def get_scrolled(self, scroll):
|
|
scrolled_pos = [self.mouse_pos[0] + scroll.scroll[0],
|
|
self.mouse_pos[1] + scroll.scroll[1]]
|
|
return scrolled_pos
|
|
|
|
|
|
def distance_indicator(coords1, coords2):
|
|
x_distance = abs(coords1[0] - coords2[0])
|
|
y_distance = abs(coords1[1] - coords2[1])
|
|
distance = math.sqrt((x_distance ** 2) + (y_distance ** 2))
|
|
return round(distance, 4)
|
|
|
|
|
|
def load_images(path, name, number_of_images, file_type=".png"):
|
|
images = []
|
|
for i in range(number_of_images):
|
|
images.append(pygame.image.load("{}/{}{}{}".format(path, name, i, file_type)).convert())
|
|
return images
|
|
|
|
|
|
def load_map(path):
|
|
f = open(path, "r")
|
|
data = f.read()
|
|
f.close()
|
|
data = data.split('\n')
|
|
product = []
|
|
for line in data:
|
|
product.append(list(line))
|
|
return product
|
|
|
|
|
|
# next func sorts object into objects class so the objects is stored where it should be
|
|
def sort(obj, objects):
|
|
objects.game_objects.append(obj)
|
|
|
|
if obj.moving:
|
|
objects.moving_objects.append(obj)
|
|
|
|
if obj.move.collisions:
|
|
objects.collision_objects.append(obj)
|
|
|
|
|
|
def find_collisions(obj, objects):
|
|
hit_list = []
|
|
for element in objects.game_objects:
|
|
if element.object_id != obj.object_id:
|
|
if element.rect.colliderect(obj.rect):
|
|
hit_list.append(element)
|
|
return hit_list
|
|
|
|
|
|
def collision(obj, objects):
|
|
# collisions for left/right
|
|
obj.change_pos([obj.object_pos[0] + obj.movement[0], obj.object_pos[1]])
|
|
hit_list = find_collisions(obj, objects)
|
|
for item in hit_list:
|
|
if obj.movement[0] > 0:
|
|
item.hit_right(obj, objects)
|
|
elif obj.movement[0] < 0:
|
|
item.hit_left(obj, objects)
|
|
|
|
# collisions for top/bottom
|
|
obj.change_pos([obj.object_pos[0], obj.object_pos[1] + obj.movement[1]])
|
|
hit_list = find_collisions(obj, objects)
|
|
for item in hit_list:
|
|
if obj.movement[1] > 0:
|
|
item.hit_bottom(obj, objects)
|
|
elif obj.movement[1] < 0:
|
|
item.hit_top(obj, objects)
|
|
|
|
|
|
# !!!!!!!!!!! config this function for every program !!!!!!!!!!
|
|
def load_objects(game_map, width, height, objects, game):
|
|
x, y = 0, 0
|
|
for line in game_map:
|
|
for obj in line:
|
|
# this is just to be efficient normaly u can use elif and put another obj to another num
|
|
if obj == "1":
|
|
obj = Object("solid", game.custom_id_giver, [x, y], [0, 0], 0, False, [width, height])
|
|
obj.memory.append(3)
|
|
sort(obj, objects)
|
|
game.custom_id_giver += 1
|
|
x += width
|
|
y += height
|
|
x = 0
|
|
|
|
|
|
def load_textures(objects, dictionary, display, scroll):
|
|
for object in objects.game_objects:
|
|
if object.special:
|
|
display.blit(object.specific.images[object.specific.attribute_0],
|
|
[object.object_pos[0] - scroll.scroll[0], object.object_pos[1] - scroll.scroll[1]])
|
|
else:
|
|
display.blit(dictionary["{}".format(object.type)],
|
|
[object.object_pos[0] - scroll.scroll[0], object.object_pos[1] - scroll.scroll[1]])
|
|
|
|
|
|
def load_sp_texture(objects, type_x, image):
|
|
for object in objects.special_objects:
|
|
if object.type == type_x:
|
|
object.attributes.images.append(image)
|
|
|
|
|
|
def load_bg(image, y_x, width, height, display):
|
|
pos = [0, 0]
|
|
for i in range(y_x[0]):
|
|
for j in range(y_x[1]):
|
|
display.blit(image, pos)
|
|
pos[0] += width
|
|
pos[0] = 0
|
|
pos[1] += height
|
|
|
|
|
|
def find_angle_between_points(center, point):
|
|
dists = distances(center, point)
|
|
try:
|
|
angle = math.atan(dists[1] / dists[0])
|
|
|
|
if point[0] < center[0]:
|
|
if point[1] < center[1]:
|
|
return angle + math.pi
|
|
else:
|
|
return (math.pi / 2 - angle) + (math.pi / 2)
|
|
else:
|
|
if point[1] < center[1]:
|
|
return (math.pi / 2 - angle) + 3 * (math.pi / 2)
|
|
else:
|
|
return angle
|
|
except ZeroDivisionError:
|
|
return False
|
|
|
|
|
|
def distances(cords1, cords2):
|
|
return [abs(cords1[0] - cords2[0]), abs(cords1[1] - cords2[1])]
|
|
|
|
|
|
def average(*args):
|
|
sumX = 0
|
|
for item in args:
|
|
sumX += item
|
|
return sumX/len(args)
|
|
|
|
|
|
def area_intersection_of_circles(points, radius_list):
|
|
try:
|
|
dist = distance_indicator(points[0], points[1])
|
|
|
|
alpha_cos = (pow(radius_list[1], 2) + pow(dist, 2) - pow(radius_list[0], 2)) / (2 * radius_list[1] * dist)
|
|
|
|
alpha = math.acos(alpha_cos)
|
|
|
|
beta_cos = (dist - alpha_cos * radius_list[1]) / radius_list[0]
|
|
|
|
beta = math.acos(beta_cos)
|
|
|
|
triangles = (alpha_cos * pow(radius_list[1], 2) * math.sin(alpha)) + (
|
|
beta_cos * pow(radius_list[0], 2) * math.sin(beta))
|
|
|
|
arcs = ((math.pi * pow(radius_list[0], 2) * beta * 2) / math.tau) + (
|
|
(math.pi * pow(radius_list[1], 2) * alpha * 2) / math.tau)
|
|
|
|
return arcs - triangles
|
|
except:
|
|
return False
|