tangledmind/models.py

# -*- coding: UTF-8 -*-

### Tangled Mind
### Author: Arthur 'Grizzly' Grisel-Davy

import pygame
from time import time
from math import atan, degrees,radians, cos, sin

from utils import *

img_path = 'asset/'


with open(r'./config.yaml') as file:
    data = yaml.load(file,Loader=yaml.FullLoader)

    max_fire_rate = data['max_fire_rate'] # in fires per seconds
    cap_speed = data['cap_speed']
    acceleration = data['acceleration']
    deceleration = data['deceleration']



class Game():
    def __init__(self,carte,player,camera,enemies,hud):
        self.carte = carte
        self.player = player
        self.camera = camera
        self.enemies = enemies
        self.hud = hud

    def draw(self,surface):
        # draw the map
        self.carte.draw(surface,self.camera)

        # draw the projectiles and remove them if needed
        to_remove = []
        for k,proj in enumerate(self.player.projectiles):
            if not proj.is_out(self.carte,self):
                proj.move()
                proj.draw(surface,self.camera)
            else:
                to_remove.append(k)
        if to_remove != []:
            for k in to_remove[::-1]:
                del self.player.projectiles[k]

        for enemy in self.enemies:
            enemy.draw(surface,self.camera)

        self.player.draw(surface,self.camera)
        self.camera.draw(surface)
        self.hud.draw(surface)

    def get_offset(self):
        #Return the position of the elements on the screen (camera)
        return (self.player.posx-self.camera.posx,self.player.posy-self.camera.posy)

class Hud():
    def __init__(self,player):
        self.player = player
        self.ratio = 1
        self.font = pygame.font.SysFont('GlacialIndifference-Regular', 72)

    def draw(self,surface):
        # draw the life bar
        pygame.draw.rect(surface,(255,0,0),(10,10,round(self.player.life/100*surface.get_width()/3),30),0)
        pygame.draw.rect(surface,(255,255,255),(10,10,int(surface.get_width()/3),30),3)

        text = self.font.render(str(self.player.ammo), True, (255, 255, 255))
        surface.blit(text, (int(surface.get_width()-1.5*text.get_width()),int(surface.get_height()-1.5*text.get_height())))


class Carte():
    def __init__(self,n):
        self.carte, self.player_start_pos, self.back = map_generator(n)

    def draw(self,surface,camera):
        offsetx,offsety = camera.get_offset()
        for room in self.carte:
            surface.blit(self.back,(room[2][0]-offsetx,room[2][1]-offsety))
            surface.blit(room[0],(room[2][0]-offsetx,room[2][1]-offsety))

    def collision(self,thing):
        #print(f"player in position {thing.posx,thing.posy}")
        for room in self.carte:
            if room[1].overlap(thing.mask, (thing.posx-thing.rect.center[0]-room[2][0],thing.posy-thing.rect.center[1]-room[2][1])):
                return True

        return False


class Camera():
    def __init__(self,start_pos,screen_width,screen_height,box_ratio):
        self.posx = start_pos[0]
        self.posy = start_pos[1]
        self.screen_height = screen_height
        self.screen_width = screen_width
        self.box_ratio = box_ratio
        self.box = pygame.Rect(int(screen_width*box_ratio),
                                int(screen_height*box_ratio),
                                int(screen_width*(1-2*box_ratio)),
                                int(screen_height*(1-2*box_ratio)))

    def draw(self,surface):
        pass
        # pygame.draw.line(surface, (255,0,0), (int(surface.get_width()/2-20),int(surface.get_height()/2)), (int(surface.get_width()/2+20),int(surface.get_height()/2)), 3)
        # pygame.draw.line(surface, (255,0,0), (int(surface.get_width()/2),int(surface.get_height()/2-20)), (int(surface.get_width()/2),int(surface.get_height()/2+20)), 3)
        # pygame.draw.rect(surface, (0,255,0), self.box, 3)
    def get_offset(self):
        return (int(self.posx-self.screen_width/2),int(self.posy-self.screen_height/2))


class Player():
    def __init__(self,name,start_pos,center_screen,key_up,key_down,key_left,key_right,key_fire,texture,texture_canon,texture_proj):
        self.name = name
        self.posx = start_pos[0]
        self.posy = start_pos[1]
        self.speed = [0,0]

        self.key_up = key_up
        self.key_down = key_down
        self.key_left = key_left
        self.key_right = key_right
        self.key_fire = key_fire

        self.img_player = pygame.image.load(img_path+texture).convert_alpha()
        self.player = self.img_player
        self.rect = self.player.get_rect()
        self.mask = pygame.mask.from_surface(self.img_player)

        self.img_canon = pygame.image.load(img_path+texture_canon).convert_alpha()
        self.canon = self.img_canon
        self.canon_rect = self.canon.get_rect()
        self.degres_player = 0
        self.degres_canon = 0
        self.texture_proj = texture_proj

        self.projectiles = []
        self.last_fire = time()

        # RP attributes:
        self.life = 100
        self.ammo = 50


    def check_keys(self,keystate,screen_width,screen_height,carte,camera):

        # If an interresting key is pressed
        if keystate[self.key_left] or keystate[self.key_right] or keystate[self.key_up] or keystate[self.key_down]:

            if keystate[self.key_left]:
                self.speed[0] -= acceleration
                if self.speed[0] < -cap_speed: self.speed[0] = -cap_speed   

            if keystate[self.key_right]:
                self.speed[0] += acceleration
                if self.speed[0] > cap_speed: self.speed[0] = cap_speed

            if keystate[self.key_up]:
                self.speed[1] -= acceleration
                if self.speed[1] < -cap_speed: self.speed[1] = -cap_speed

            if keystate[self.key_down]:
                self.speed[1] += acceleration
                if self.speed[1] > cap_speed: self.speed[1] = cap_speed

        # Begin the deceleration
        if not (keystate[self.key_left] or keystate[self.key_right]):
            self.speed[0] = int(self.speed[0]/deceleration)
        if not (keystate[self.key_up] or keystate[self.key_down]):
            self.speed[1] = int(self.speed[1]/deceleration)

        # get pos of player on screen to check collision with the movement box
        offsetx,offsety = camera.get_offset()
        posx_screen = self.posx-offsetx
        posy_screen = self.posy-offsety

        # player in the box:
        if camera.box.collidepoint(posx_screen,posy_screen):

            # X AXIS
            temp_pos = self.posx
            self.posx = self.posx+self.speed[0]
            if carte.collision(self):
                self.posx = temp_pos
                self.speed[0] = 0

            # Recalculate position on screen to detect an exit of the box
            posx_screen = self.posx-offsetx
            if not camera.box.collidepoint(posx_screen,posy_screen):
                # Exit of the box, move the box so that the player stays in it
                camera.posx = camera.posx + self.speed[0]

            # Y AXIS
            temp_pos = self.posy
            self.posy = self.posy+self.speed[1]
            if carte.collision(self):
                self.posy = temp_pos
                self.speed[1] = 0

            # Recalculate position on screen to detect an exit of the box
            posy_screen = self.posy-offsety
            if not camera.box.collidepoint(posx_screen,posy_screen):
                # Exit of the box, move the box so that the player stays in it
                camera.posy = camera.posy + self.speed[1]


        # player not in the box
        else:
            # X AXIS
            temp_pos = self.posx
            self.posx = self.posx+self.speed[0]
            if carte.collision(self):
                self.posx = temp_pos
                self.speed[0] = 0
            # If the player really move, camera follow
            else:
                camera.posx = camera.posx + self.posx-temp_pos

            # Y AXIS
            temp_pos = self.posy
            self.posy = self.posy+self.speed[1]
            if carte.collision(self):
                self.posy = temp_pos
                self.speed[1] = 0
            # If the player really move, camera follow
            else:
                camera.posy = camera.posy + self.posy-temp_pos


        if keystate[self.key_fire]:
            self.fire('bullet','asset/projectile')


    def draw(self,surface,camera):

        #Get offset and compute player position in screen
        offsetx,offsety = camera.get_offset()
        posx_screen = self.posx-offsetx
        posy_screen = self.posy-offsety

        #Calculate canon rotation:
        x_mouse, y_mouse = pygame.mouse.get_pos()
        if x_mouse==posx_screen:
                x_mouse+=0.1
        self.degres_canon = -1*degrees(atan((y_mouse-posy_screen)/(x_mouse-posx_screen)))
        if x_mouse < posx_screen:
            self.degres_canon = 180+self.degres_canon
        self.canon = pygame.transform.rotate(self.img_canon,self.degres_canon)

        # Get rects
        self.rect = self.player.get_rect()
        self.canon_rect = self.canon.get_rect()

        # blit player and canon
        surface.blit(self.player,(posx_screen-self.rect.center[0],posy_screen-self.rect.center[1]))
        surface.blit(self.canon,(posx_screen-self.canon_rect.center[0],posy_screen-self.canon_rect.center[1]))

        #pygame.draw.rect(surface, (255,0,0), (int(move_box_ratio*scwidth),int(move_box_ratio*scheight),int(scwidth*(1-2*move_box_ratio)),int(scheight*(1-2*move_box_ratio))), 2)

    def fire(self,name,texture):
        if (time()-self.last_fire> 1/max_fire_rate):
            new_proj = Projectile(name,self.texture_proj,(self.posx,self.posy),20,self.degres_canon)
            self.projectiles.append(new_proj)
            self.last_fire = time()
            self.ammo = self.ammo -1


class Enemy():
    def __init__(self,name,position,texture):
        self.name = name
        self.posx = position[0]
        self.posy = position[1]

        self.img = pygame.image.load(img_path+texture).convert_alpha()
        self.rect = self.img.get_rect()
        self.mask = pygame.mask.from_surface(self.img)

    def draw(self,surface,camera):
        offsetx,offsety = camera.get_offset()
        posx_screen = self.posx-offsetx
        posy_screen = self.posy-offsety
        surface.blit(self.img,(posx_screen-self.rect.center[0],posy_screen-self.rect.center[1]))

    def die(self,game,index):
        print(f"{self.name} died with honor.")
        del game.enemies[index]


class Projectile(): 

    def __init__(self,name,texture,position,speed,angle):
        self.name = name
        self.speed = speed
        self.posx = position[0]
        self.posy = position[1]
        #self.deplacement = [0,0]
        self.direction = direction = [cos(radians(angle)),-sin(radians(angle))]
        self.img = pygame.transform.rotate(pygame.image.load(img_path+texture).convert_alpha(),angle)
        self.rect = self.img.get_rect()
        self.mask = pygame.mask.from_surface(self.img)

    def move(self):
        self.posx = round(self.posx+self.speed*self.direction[0])
        self.posy = round(self.posy+self.speed*self.direction[1])
        #self.deplacement = (round(self.deplacement[0]+self.speed*self.direction[0]),round(self.deplacement[1]+self.speed*self.direction[1]))
    
    def draw(self,surface,camera):
        # Get position on screen
        offsetx,offsety = camera.get_offset()
        posx_screen = self.posx-offsetx
        posy_screen = self.posy-offsety

        surface.blit(self.img,(posx_screen-self.rect[0],posy_screen-self.rect[1]))

    def is_out(self,carte,game):
        # A projectile is out if it touches a wall or an enemy. Otherwise it continues.

        impact = False

        # Touchs a wall
        if carte.collision(self):
            impact = True

        # Touchs an enemy
        for k,enemy in enumerate(game.enemies):
            if enemy.mask.overlap(self.mask, (enemy.posx+enemy.rect.center[0]-self.posx-self.rect.center[0],enemy.posy+enemy.rect.center[1]-self.posy-self.rect.center[1])):
                print("Impact on enemy {} at position {}".format(enemy.name,(enemy.posx,enemy.posy)))
                enemy.die(game,k)
                impact = True

        return impact