# Wyatt Austin and Jacob Espinoza

import pygame
import math
import random

pygame.init()

screenWidth = 800
screenHeight = 600

black = (0, 0, 0)
white = (255, 255, 255)
red = (255, 0, 0)
green = (0, 255, 0)
blue = (0, 0, 255)

gameDisplay = pygame.display.set_mode((screenWidth, screenHeight))
pygame.display.set_caption('better asteroids')
clock = pygame.time.Clock()

largeFont = pygame.font.SysFont('Comic Sans MS', 30)
smallFont = pygame.font.SysFont('Comic Sans MS', 15)


def displayText(size, x, y, text, color = black):
    if size == 'large':
        textSurface = largeFont.render(text, False, color)
    if size == 'small':
        textSurface = smallFont.render(text, False, color)

    gameDisplay.blit(textSurface,(x, y))


'''
class myList():
    def __init__(self):
        self.list = []

    def appendList(self, item):
        self.list += item

    def getList(self):
        return self.list
'''

class playerShip():
    def __init__(self):
        self.x = screenWidth / 2
        self.y = screenHeight / 2
        self.angle =  math.pi / 2
        self.xVel = 0
        self.yVel = 0
        self.angleChange = 0
        self.velocityChange = 0
        masterList.append(self)

    def getX(self):
        return self.x

    def getY(self):
        return self.y

    def draw(self):
        drawShip(self.x, self.y, self.angle)

    def tick(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                exit.exit = True
                pygame.quit()
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_LEFT:
                    self.angleChange = -.1
                if event.key == pygame.K_RIGHT:
                    self.angleChange = .1
                if event.key == pygame.K_UP:
                    self.velocityChange = .1
                if event.key == pygame.K_f:
                    newBullet = bullet(self.x, self.y, self.angle, 10, red, self.xVel, self.yVel)
                    myBulletList.append(newBullet)
            if event.type == pygame.KEYUP:
                if event.key == pygame.K_RIGHT or event.key == pygame.K_LEFT:
                    self.angleChange = 0
                if event.key == pygame.K_UP:
                    self.velocityChange = 0
        if self.x < 0:
            self.x = screenWidth
        if self.x > screenWidth:
            self.x = 0
        if self.y < 0:
            self.y = screenHeight
        if self.y > screenHeight:
            self.y = 0

        #clean up
        self.angle += self.angleChange
        self.xVel += self.velocityChange * math.cos(self.angle)
        self.yVel += self.velocityChange * math.sin(self.angle)
        self.x += self.xVel
        self.y += self.yVel

def drawShip(x, y, angle):
    pygame.draw.circle(gameDisplay, green, (int(x), int(y)), 20)

    pygame.draw.circle(gameDisplay, blue, (int(x + math.cos(angle) * 15), int(y + math.sin(angle) * 15)), 10)




def createBullet(x, y, angle, velocity):
    newBullet = bullet(x, y, angle, velocity)

class bullet:
    def __init__(self, x, y, angle, velocity, color = red, prevXVel = 0, prevYVel = 0):
        self.x = x
        self.y = y
        self.xVel = math.cos(angle) * velocity + prevXVel
        self.yVel = math.sin(angle) * velocity + prevYVel
        self.color = color
        masterList.append(self)

    def tick(self):
        self.x += self.xVel
        self.y += self.yVel
        if self.x <= 0 or self.x >= screenWidth or self.y <= 0 or self.y >= screenHeight:
            masterList.remove(self)
            try:
                enemyBulletList.remove(self)
            except:
                try:
                    myBulletList.remove(self)
                except:
                    pass

    def draw(self):
        pygame.draw.circle(gameDisplay, self.color, (int(self.x), int(self.y)), 2)


class enemyBasic:
    def __init__(self):
        rNumber = random.randint(1,4)
        if rNumber == 1:
            #start left, go right
            self.x = 0
            self.y = random.randrange(0, screenHeight)
            self.angle = 0
            self.xVel = 4
            self.yVel = 0
        if rNumber == 2:
            #start right, go left
            self.x = screenWidth
            self.y = random.randrange(0, screenHeight)
            self.angle = math.pi
            self.xVel = -4
            self.yVel = 0
        if rNumber == 3:
            #start top, go down
            self.x = random.randrange(0, screenWidth)
            self.y = 0
            self.angle = math.pi / 2
            self.xVel = 0
            self.yVel = 4
        if rNumber == 4:
            #start bot, go up
            self.x = random.randrange(0, screenWidth)
            self.y = screenHeight
            self.angle = (3 * math.pi) / 2
            self.xVel = 0
            self.yVel = -4

        self.reloadMaxTime = 30
        self.reloadTime = self.reloadMaxTime
        masterList.append(self)
        enemyBasicList.append(self)

    def draw(self):
        pygame.draw.circle(gameDisplay, red, (int(self.x), int(self.y)), 20)
        pygame.draw.circle(gameDisplay, red, (int(self.x + math.cos(self.angle) * 15), int(self.y + math.sin(self.angle) * 15)), 10)
        if self.reloadTime <= 15:
            pygame.draw.circle(gameDisplay, green, (int(self.x), int(self.y)), int(self.reloadTime / 2))

    def tick(self):
        self.x += self.xVel
        self.y += self.yVel
        if self.reloadTime <= 0:
            self.shoot()
        else:
            self.reloadTime += -1
        if self.x > screenWidth:
            self.x = 0
        if self.x < 0:
            self.x = screenWidth
        if self.y < 0:
            self.y = screenHeight
        if self.y > screenHeight:
            self.y = 0

    def shoot(self):
        '''
        create a bullet and reset reload time
        '''
        self.reloadTime = self.reloadMaxTime
        newBullet = bullet(self.x, self.y, -self.aim(player.getX(), player.getY()), 10, green)
        enemyBulletList.append(newBullet)

    def aim(self, x, y):
        '''
        calculate angle between object and its target
        '''
        xDif = self.x - x
        yDif = y - self.y
        try:
            angle = math.atan2(yDif, xDif)
            return angle - math.pi
        except:
            return (3 * math.pi / 2)



class enemyTurret:
    def __init__(self):
            #start left, go right
        self.x = random.randint(0,screenWidth)
        self.y = random.randrange(0, screenHeight)
        self.reloadMaxTime = 120
        self.reloadTime = self.reloadMaxTime
        masterList.append(self)
        enemyTurretList.append(self)
        self.fireTime = 10
        self.health = 3

    def draw(self):
        pygame.draw.circle(gameDisplay, blue, (int(self.x), int(self.y)), 20)
        if self.reloadTime <= 15:
            pygame.draw.circle(gameDisplay, green, (int(self.x), int(self.y)), int(self.reloadTime / 2))

    def tick(self):
        if self.reloadTime <= 0:
            self.shoot()
        else:
            self.reloadTime += -1

    def shoot(self):
        '''
        create a bullet and reset reload time
        '''
        if self.fireTime <= 0:
            self.reloadTime = self.reloadMaxTime
            self.fireTime = 10
        newBullet = bullet(self.x, self.y, -self.aim(player.getX(), player.getY()), 10, green)
        enemyBulletList.append(newBullet)
        self.fireTime += -1

    def aim(self, x, y):
        '''
        calculate angle between object and its target
        '''
        xDif = self.x - x
        yDif = y - self.y
        try:
            angle = math.atan2(yDif, xDif)
            return angle - math.pi
        except:
            return (3 * math.pi / 2)

    def hurt(self, bullet):
        self.health += -1
        if self.health <= 0:
            masterList.remove(self)
            enemyTurretList.remove(self)
            Score.score += 40
        myBulletList.remove(bullet)
        masterList.remove(bullet)


def collided(ship, bullet):
    #radius 20 for ships
    #if distance between ship and bullet < 20: return True
    distance = ((ship.x - bullet.x) ** 2 + (ship.y - bullet.y) ** 2) ** .5
    if distance < 20:
        return True
    return False

#masterList to draw
masterList = []

enemyBasicList = []
enemyTurretList = []

enemyBulletList = []
myBulletList = []

class score:
    def __init__(self):
        self.score = 0

Score = score()

player = playerShip()
masterList.append(player)

print('note: bullets inherit your ships velocity')


def gameLoop():
    exit = False

    state = 'start'




    try:
        pygame.mixer.music.load('a.ogg')
        pygame.mixer.music.play(-1)
    except:
        pass


    start = True
    while not exit:
        if state == 'start':
            gameDisplay.fill(white)
            #display instructions
            xBase = screenWidth / 2 - 100
            yBase = screenHeight / 2 - 200
            displayText('large', xBase, yBase, 'Moon Rocks')
            displayText('small', xBase, yBase + 200, 'press esc to play')
            pygame.display.update()
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    #exit = True
                    pygame.quit()
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_ESCAPE:
                        state = 'play'
        if state == 'play':
            for i in masterList:
                i.tick()

            gameDisplay.fill(white)
            displayText('large', 0, 0, str.format('Score: {}', Score.score))
            for i in masterList:
                i.draw()


            pygame.display.update()
            if start == True:
                #wait 3 seconds
                start = False
            clock.tick(20)

            '''
            print(masterList)
            count = 0
            for i in masterList:
                count += 1
            print(count)
            '''

            for i in enemyBulletList:
                if collided(player, i):
                    state = 'game over'

            for i in myBulletList:
                for h in enemyBasicList:
                    if collided(h, i):
                        masterList.remove(h)
                        enemyBasicList.remove(h)
                        Score.score += 10
                for h in enemyTurretList:
                    if collided(h, i):
                        h.hurt(i)
            #spawn enemies
            if random.randint(0, 100) == 1:
                enemy = enemyTurret()
            if random.randint(0, 200) == 1:
                enemy = enemyBasic()
            '''

            if enemyBasicList == []:
                if random.randint(0,15) == 1:
                    enemy = enemyBasic()
            '''

        if state == 'game over':
            gameDisplay.fill(white)

            # display game over screen + score
            displayText('large', xBase, yBase, str.format('Final Score: {}', Score.score))
            pygame.display.update()
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    pygame.quit()
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_ESCAPE:
                        pygame.quit()


gameLoop()
quit()