You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

195 lines
7.4 KiB
Python

# -*- coding: UTF-8 -*-
### Tangled Mind
### Author: Arthur 'Grizzly' Grisel-Davy
import pygame
from time import time
from math import atan, degrees,radians, cos, sin
img_path = 'asset/'
cap_speed = 10
acceleration = 2
deceleration = 1.1
class Game():
def __init__(self,carte,perso):
self.carte = carte
self.perso = perso
def draw(self,surface):
# draw the map
self.carte.draw(surface,self.perso.get_draw_offset())
# draw the projectiles and remove them if needed
to_remove = []
for k,proj in enumerate(self.perso.projectiles):
if not proj.is_out(self.carte):
proj.move()
proj.draw(surface, self.perso.get_draw_offset())
else:
to_remove.append(k)
if to_remove != []:
for k in to_remove[::-1]:
del self.perso.projectiles[k]
self.perso.draw(surface)
class Carte():
def __init__(self,texture):
self.img = pygame.image.load('maps/'+texture).convert_alpha()
self.rect = self.img.get_rect()
self.mask = pygame.mask.from_surface(self.img)
def draw(self,surface,offset):
surface.blit(self.img,offset)
class Perso():
def __init__(self,name,posx,posy,center_screen,key_up,key_down,key_left,key_right,key_fire,texture,texture_canon,texture_proj):
self.name = name
self.posx = posx
self.posy = posy
self.posx_screen = center_screen[0]
self.posy_screen = center_screen[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_perso = pygame.image.load(img_path+texture).convert_alpha()
self.perso = self.img_perso
self.perso_rect = self.perso.get_rect()
self.mask = pygame.mask.from_surface(self.img_perso)
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_perso = 0
self.degres_canon = 0
self.texture_proj = texture_proj
self.projectiles = []
self.last_fire = time()
def check_keys(self,keystate,screen_width,screen_height,carte):
# 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)
# Update the position on x axis
self.posx = self.posx+self.speed[0]
# If new position cause to enter a wall, rollback to last position (i.e. don't move)
if carte.mask.overlap(self.mask, (self.posx-self.perso_rect.center[0],self.posy-self.perso_rect.center[1])):
self.posx = self.posx-self.speed[0]
self.speed[0] = 0
# Update the position on y axis
self.posy = self.posy+self.speed[1]
if carte.mask.overlap(self.mask, (self.posx-self.perso_rect.center[0],self.posy-self.perso_rect.center[1])):
self.posy = self.posy-self.speed[1]
self.speed[1] = 0
if keystate[self.key_fire]:
self.fire('bullet','asset/projectile')
def draw(self,surface):
#Calculate player rotation:
# if self.speed != [0,0]:
# if self.speed[0]!=0:
# self.degres_perso = -1*degrees(atan(self.speed[1]/self.speed[0]))
# if self.speed[0] < 0:
# self.degres_perso = 180+self.degres_perso
# else:
# self.degres_perso = ((self.speed[1]>0)*2-1)*-90
# self.perso = pygame.transform.rotate(self.img_perso,self.degres_perso)
#Calculate canon rotation:
x_mouse, y_mouse = pygame.mouse.get_pos()
if x_mouse==self.posx_screen:
x_mouse+=0.1
self.degres_canon = -1*degrees(atan((y_mouse-self.posy_screen)/(x_mouse-self.posx_screen)))
if x_mouse < self.posx_screen:
self.degres_canon = 180+self.degres_canon
self.canon = pygame.transform.rotate(self.img_canon,self.degres_canon)
# Get rects
self.perso_rect = self.perso.get_rect()
self.canon_rect = self.canon.get_rect()
# Blits
surface.blit(self.perso,(self.posx_screen-self.perso_rect.center[0],self.posy_screen-self.perso_rect.center[1]))
#hitbox = pygame.Rect(self.posx_screen-self.perso_rect.center[0],self.posy_screen-self.perso_rect.center[1],self.perso_rect[2],self.perso_rect[3])
#print(hitbox)
surface.blit(self.canon,(self.posx_screen-self.canon_rect.center[0],self.posy_screen-self.canon_rect.center[1]))
#pygame.draw.rect(surface, (255,0,0), hitbox, 2)
def fire(self,name,texture):
if (time()-self.last_fire> 0.2):
new_proj = Projectile(name,self.texture_proj,(self.posx,self.posy),20,self.degres_canon)
self.projectiles.append(new_proj)
self.last_fire = time()
def get_draw_offset(self):
return((self.posx_screen-self.posx,self.posy_screen-self.posy))
class Projectile(pygame.sprite.Sprite):
def __init__(self,name,texture,position,speed,angle):
self.name = name
self.speed = speed
self.pos_init = position
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.deplacement = (round(self.deplacement[0]+self.speed*self.direction[0]),round(self.deplacement[1]+self.speed*self.direction[1]))
def draw(self,surface,offset):
surface.blit(self.img,(offset[0]+self.pos_init[0]+self.deplacement[0]-self.rect[0],offset[1]+self.pos_init[1]+self.deplacement[1]-self.rect[1]))
def is_out(self,carte):
abs_pos = (self.pos_init[0]+self.deplacement[0],self.pos_init[1]+self.deplacement[1])
if carte.mask.overlap(self.mask, (abs_pos[0]-self.rect.center[0],abs_pos[1]-self.rect.center[1])):
# if (self.deplacement[0]+surface.get_width()/2<0-self.img.get_width() or
# self.deplacement[1]+surface.get_height()/2<0-self.img.get_height() or
# self.deplacement[0]+surface.get_width()/2>surface.get_width()+self.img.get_width() or
# self.deplacement[1]+surface.get_height()/2>surface.get_height()+self.img.get_height()):
return True
else:
return False