class Dog:
    name = ''
    age = 0

# Dog is called like a function to **instantiate** the object
fido = Dog()
# have to set the variables manually
fido.name = "Fido"
fido.age = 7

import pygame
from settings import *

class Game:
    def __init__(self):

        self.walls = []
        self.hero = None
        self.done = False

        pygame.init()
        self.screen = pygame.display.set_mode(WINDOW_SIZE)
        self.clock = pygame.time.Clock()
        pygame.display.set_caption(TITLE)

def run(self):
    while not self.done:
        #### EVENT CHECK SECTION
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                self.done = True
            ## extra stuff will go here

        ### clear the screen
        self.screen.fill(WHITE)

        ## extra stuff will go here

        #### update the display and move forward 1 frame
        pygame.display.flip()
        # --- Limit to 60 frames per second
        self.clock.tick(FPS)

import pygame
from settings import *
from hero import *

class Hero:
    def __init__(self, x, y, w, h):
        ''' The hero constructor function '''
        self.rect = Rect(x, y, w, h)
        ## other things could/should go here

    def move_right(self, step_size=SPEEDX):
        ''' Move the hero to the right '''
        pass

    def move_left(self, step_size=SPEEDX):
        ''' Move the hero to the left '''
        pass

    def move_up(self, step_size=SPEEDY):
        ''' Move the hero up '''
        pass

    def move_down(self, step_size=SPEEDY):
        ''' Move the hero down '''
        pass

    def drift(self):
        ''' drift across the screen

        Note: the implementation should drift x and drift y separately
              After the drift in x, it should check for x collisions
              After the drift in y, it should check for y collisions
        '''
        pass

    def drift_x(self):
        ''' Handle the drift in x '''
        pass

    def drift_y(self):
        ''' Handle the drift in y '''
        pass

    def collides_with(self, other_rect):
        ''' return true if there is a collision '''
        pass

    def handle_xcollision(self, other_rect):
        ''' handle collisions going left and right '''
        pass

    def handle_ycollision(self, other_rect):
        ''' handle collisions going up and dowon '''
        pass

class Hero:
    ### all other things here

    def update(self, walls):
        ''' move and check for collisions '''
        pass

    def draw(self, screen)
        ''' draw the hero '''
        pass

class Game:
    def __init__(self):

        self.walls = []
        self.hero = None
        self.done = False

        pygame.init()
        self.screen = pygame.display.set_mode(WINDOW_SIZE)
        self.clock = pygame.time.Clock()
        pygame.display.set_caption(TITLE)


    def setup(self):
        self.hero = Hero(___) ### fill in the underline

    def run(self):
        while not self.done:
            #### EVENT CHECK SECTION
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.done = True
                ## extra stuff will go here

            ### clear the screen
            self.screen.fill(WHITE)

            if self.hero is not None:
                self.hero.update(self.walls)
                self.hero.draw()

            #### update the display and move forward 1 frame
            pygame.display.flip()
            # --- Limit to 60 frames per second
            self.clock.tick(FPS)



### this changes the running to:
game = Game()
game.setup()
game.run()

class Walls:
    def __init__(self):
        ''' keep track of the walls
        you could maybe pass in a COLOR here'''
        self.walls = []

    def add_wall(self, x, y, w, h):
        ''' add a single wall'''
        self.walls.append(Rect(x,y,w,h))

    def parse_level(self, level):
        '''Parse a level string into a set of walls. I've made this for you'''
        level_width = len(level[0])
        wall_width = WIDTH / level_width

        level_height = len(level)
        wall_height = HEIGHT / level_height

        for row_index in range(level_height):
            for col_index in range(level_width):
                cell = level[row_index][col_index]
                if "cell" == "W":
                    x = wall_width * col_index
                    y = wall_height * row_index
                    self.add_wall(x, y, wall_width, wall_height)

    def set_example_level(self):
        level = [
            "WWWWWWWWWWWWW",
            "W      W    W",
            "W  W   W    W",
            "W  W   W    W",
            "W  W        W",
            "WWWWWWWWWWWWW"
        ]
        self.parse_level(level)

    def draw(self, screen):
        for wall in self.walls:
            ### fill in the pygame draw code here.

class Game:
    ## code was here

    def run(self):
        while not self.done:
            #### EVENT CHECK SECTION
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.done = True
                else:
                    self.handle_event(event)

            ### the rest of the game loop here

    def handle_event(self, event):
        ## do various checks for events here.
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_LEFT:
                ## code here
            elif event.key == pygame.K_RIGHT:
                ## code here
            elif event.key == pygame.K_DOWN:
                ## code here
            elif event.key == pygame.K_UP:
                ## code here

##### INIT SECTION
# import pygame
# any functions you want to use should be defined right away
# create pygame variables
# create variables you want to use inside the game loop


##### WHILE LOOP SECTION
while not done:
    # check for events
    # fill the screen with white
    ##### ACTION CODE
    # do any actions that we want to do
    # this could be moving the box, etc
    ##### FINISHING CODE
    # end of while loop code, mostly the clock.tick()

#### POST WHILE LOOP SECTION
# once the code hits here, we can assume that the while loop is over and game is done
# do any last finishing code things here
# the important one is to tell pygame shut down

origin_x = 50
origin_y = 50
square_width = 100
square_height = 100

# the syntax for rect is (display surface, color, rectangle_info)
# and the rectangle_info is (x, y, width, height)
pygame.draw.rect(surface, BLACK, [origin_x, origin_y, square_width, square_height])

box_info = {'x': 50, 'y': 50, 'width': 100, 'height': 100}

# the syntax for rect is (display surface, color, rectangle_info)
# and the rectangle_info is (x, y, width, height)
pygame.draw.rect(surface, BLACK, [box_info['x'], box_info['y'], box_info['width'], box_info['height']])

def make_box(x, y, width, height):
    new_box_info = {'x': x, 'y': y, 'width': width, 'height': height}
    return new_box_info

box_info = make_box(50, 50, 100, 100)

# the syntax for rect is (display surface, color, rectangle_info)
# and the rectangle_info is (x, y, width, height)
pygame.draw.rect(surface, BLACK, [box_info['x'], box_info['y'], box_info['width'], box_info['height']])

def make_box(x, y, width, height):
    new_box_info = {'x': x, 'y': y, 'width': width, 'height': height}
    return new_box_info

def draw_box(surf, color, info):
    pygame.draw.rect(surf, color, [info['x'], info['y'], info['width'], info['height']])

box_info = make_box(50, 50, 100, 100)

# the syntax for rect is (display surface, color, rectangle_info)
# and the rectangle_info is (x, y, width, height)
draw_box(surface, BLACK, box_info)

##### INIT SECTION
# import pygame
# any functions you want to use should be defined right away
# create pygame variables
# create variables you want to use inside the game loop


##### WHILE LOOP SECTION
while not done:
    # check for events
    # fill the screen with white
    ##### ACTION CODE
    # do any actions that we want to do
    # this could be moving the box, etc
    ##### FINISHING CODE
    # end of while loop code, mostly the clock.tick()

#### POST WHILE LOOP SECTION
# once the code hits here, we can assume that the while loop is over and game is done
# do any last finishing code things here
# the important one is to tell pygame shut down

# set up the class and the variables

class Box:
    x = 0
    y = 0
    w = 0
    h = 0
    speedx = 0
    speedy = 0

box_info = Box()
box_info.x = 50
box_info.y = 50
box_info.w = 100
box_info.h = 100
box_info.speedx = 10
box_info.speedy = 10

# Use the box_info object to draw!

pygame.draw.rect(surface, BLACK, [box_info.x, box_info.y, box_info.w, box_info.h])

# get the screen width and height

screen = pygame.display.get_surface()
W, H = screen.get_size()

# calculate special variables

right_side = box_info.x + box_info.w
left_side = box_info.x
top_side = box_info.y
bottom_side = box_info.y + box_info.h

# Compute the new position using the box_info object

def update_position(box_info):
    ### test if the box is out of bounds
    ### if it is,
    ###        the speed should negative for
    ###        the corresponding side that is out of bounds
    ###
    ### then update the position by the speed
    ### so, the x changes by speed
    ### the y changes by speed

# Compute the new position using the box_info object

class Box:
    x = 0
    y = 0
    w = 0
    h = 0
    speedx = 0
    speedy = 0

    def update_position(self):
        ### everything stays the same, except you can get access to the variables using "self" now
        ### test if the box is out of bounds
        ### if it is,
        ###        the speed should negative for
        ###        the corresponding side that is out of bounds
        ###
        ### then update the position by the speed
        ### so, the x changes by speed
        ### the y changes by speed

## assume we do
## box = Box()
## then, later, you can use it with
## box.update_position()

### inside WHILE LOOP section
for event in pygame.event.get():
    ## standard quit
    if event.type == pygame.QUIT:
        done = True
    elif event.type == pygame.KEYDOWN:
        if event.key == pygame.K_SPACE:
            print("Do something here!")
        elif event.key == pygame.K_LEFT:
            print("do something here!")
        elif event.key == pygame.K_RIGHT:
            print("do something here!")

class Box:
    def __init__(self, x, y, w, h):
        self.x = x
        self.y = y
        self.w = w
        self.h = h

box = Box(50, 50, 100, 100)

# recall that
#          x += y
# is the same as
#          x = x + y

### for physics

upforce = 0 # should be some number, maybe from bouncing or jumping

gravity = 9.8 # is positive because 0 is the top and we want it to fall down
downforce = gravity * box.mass

totalforce = downforce+upforce
acceleration = totalforce / box.mass

### update speeds and locations
box.speedy += acceleration
box.y += box.speedy

def compute_acceleration(box, did_jump=False):
    gravity_force = 9.8 * box.mass
    downforce = gravity_force # + any other downward forces

    if did_jump:
        jump_force = somenumber * box.mass
    else:
        jump_force = 0
    upforce = jump_force # + any other upward forces; maybe bouncing

    total_force = downforce + upforce
    acceleration = total_force / box.mass # f = m*a

    return acceleration

class Box:
    x = 0
    y = 0
    w = 10
    h = 10

    def print_info(self):
        pass

    @property
    def right_side(self):
        return self.x + self.w

box = Box()
box.x = 50
print(box.print_info, type(box.print_info))
print(box.right_side, type(box.right_side))

### inside WHILE LOOP section
for event in pygame.event.get():
    ## standard quit
    if event.type == pygame.QUIT:
        done = True
    elif event.type == pygame.KEYDOWN:
        if event.key == pygame.K_SPACE:
            spacedown = True
    elif event.type == pygame.KEYUP:
        if event.key == pygame.K_SPACE:
            spacedown = False

##### INIT SECTION
# import pygame
# any functions you want to use should be defined right away
# create pygame variables
# create variables you want to use inside the game loop


##### WHILE LOOP SECTION
while not done:
    # check for events
    # fill the screen with white
    ##### ACTION CODE
    # do any actions that we want to do
    # this could be moving the box, etc
    ##### FINISHING CODE
    # end of while loop code, mostly the clock.tick()

#### POST WHILE LOOP SECTION
# once the code hits here, we can assume that the while loop is over and game is done
# do any last finishing code things here
# the important one is to tell pygame shut down

class Hero:
    def __init__(self, x, y, w, h):
        ''' this is a constructor function
            when you create a new Hero, it requires these 4 variables
        '''


        # Remember that classes act like factories
        # when we are inside this function, we are inside a single Hero instance
        # and we need to be able to reference the current hero
        # so, a self variable is a way of referencing the current Hero
        self.x = x
        self.y = y
        self.w = w
        self.h = h

hero1 = Hero() # this will break.
hero1 = Hero(10, 10, 50, 50)
print(hero1.x)

class Hero:
    def __init__(self, x, y, w, h):
        ''' this is a constructor function
            when you create a new Hero, it requires these 4 variables
        '''

        # Remember that classes act like factories
        # when we are inside this function, we are inside a single Hero instance
        # and we need to be able to reference the current hero
        # so, a self variable is a way of referencing the current Hero
        self.rect = Rect(x, y, w, h)

    def say_hi(self):
        print("Hello, my name is {}".format(self.name))

    def move_right(self, step_size=0):
        self.rect.x += step_size

hero1 = Hero(10, 10, 50, 50)
print(hero1.x) # this will break
print(hero1.rect)
hero1.say_hi()

hero1.move_right(100)
hero1.move_down(100)
hero1.move_left(100)
hero1.move_up(100)

self.going_right = True
self.going_down = True

def drift(self):
    if self.going_right:
        self.move_right(SPEEDX)
    else:
        self.move_left(SPEEDX)

    if self.going_down:
        self.move_down(SPEEDY)
    else:
        self.move_up(SPEEDY)

# this will assume WINDOW_SIZE
WIDTH = WINDOW_SIZE[0]
HEIGHT = WINDOW_SIZE[1]
# you can also do "unpacking"
# WIDTH, HEIGHT = WINDOW_SIZE
wall1 = Rect(WIDTH // 2, 0, WIDTH // 10, HEIGHT)

### assume hero moves here in some way
### could be calling hero1.move()

if hero1.rect.colliderect(wall1):
    print("The hero has collided with the wall!")
    print("You should be adding code here!")

    if hero1.rect.right > wall1.left:
        hero1.rect.right = wall1.left
        hero1.going_right = False
    elif hero1.rect.left < wall1.right:
        print("Add code here!")
    elif hero1.rect.bottom > wall1.top:
        print("Add code here!")
    elif hero1.rect.top < wall1.bottom:
        print("Add code here!")

def handle_collision(self, other_rect):
    if self.rect.colliderect(other_rect):
        print("The code is basically the same from Exercise 4!")

two_thirds_height = 2 * HEIGHT//3
one_tenth_width = WIDTH // 10
one_third_width = WIDTH // 3

### Rects want x, y, w, h
### x and y are for the TOP LEFT corners.
wall1 = Rect(one_third_width, 0, one_tenth_width, two_thirds_height)
wall2 = Rect(2 * one_third_width, HEIGHT - two_thirds_height, one_tenth_width, two_thirds_height)

walls = [wall1, wall2]

for wall in walls:
    hero1.handle_collision(wall)

### inside WHILE LOOP section
for event in pygame.event.get():
    ## standard quit
    if event.type == pygame.QUIT:
        done = True
    elif event.type == pygame.KEYDOWN:
        if event.key == pygame.K_LEFT:
            hero1.move_left()

class Block(pygame.sprite.Sprite):
    def __init__(self, color, width, height):
        # Call the parent class (Sprite) constructor
        super(Block, self).__init__(self)

        # Create an image of the block, and fill it with a color.
        # This could also be an image loaded from the disk.
        self.image = pygame.Surface([width, height])
        self.image.fill(color)

        # Fetch the rectangle object that has the dimensions of the image
        # Update the position of this object by setting the values of rect.x and rect.y
        self.rect = self.image.get_rect()

class Walls:
    def __init__(self):
        ''' keep track of the walls
        you could maybe pass in a COLOR here'''
        self.walls = pygame.sprite.Group()

    def add_wall(self, x, y, w, h):
        ''' add a single wall'''
        new_block = Block(BLACK, w, h)
        new_block.x = x
        new_block.y = y
        self.walls.add(new_block)

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

# create the object!
fido = Dog("Fido", 7)

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def bark(self):
        print("Bow wow!")


fido = Dog("Fido", 7)
fido.bark()

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def bark(self):
        print("{}: Bow Wow!".format(self.name))


fido = Dog("Fido", 7)
fido.bark()

odie = Dog("Odie", 20)
odie.bark()

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def bark(self):
        print("{}: Bow Wow!".format(self.name))

    @property
    def human_age(self):
        return self.age * 7

fido = Dog("Fido", 7)
fido.bark()
print("Fido is {} in human years".format(fido.human_age))

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age

class Dog(Animal):
    def bark(self):
        print("{}: Bow Wow!".format(self.name))

    @property
    def human_age(self):
        return self.age * 7

class Cat(Animal):
    def meow(self):
        print("{}: Meow!".format(self.name))

fido = Dog("Fido", 7)
fido.bark()
print("Fido is {} in human years".format(fido.human_age))

class Animal:
    def __init__(self, name, age, number_legs, animal_type):
        self.name = name
        self.age = age
        self.number_legs = number_legs
        self.animal_type = animal_type

    def make_noise(self):
        print("Rumble rumble")

class Dog(Animal):
    def __init__(self, name, age):
        super(Dog, self).__init__(name, age, 4, "dog")

    def make_noise(self):
        self.bark()

    def bark(self):
        print("{}: Bow Wow!".format(self.name))

    @property
    def human_age(self):
        return self.age * 7

class Cat(Animal):
    def __init__(self, name, age):
        super(Dog, self).__init__(name, age, 4, "cat")

    def make_noise(self):
        self.meow()

    def meow(self):
        print("{}: Meow!".format(self.name))


fido = Dog("Fido", 7)
fido.make_noise()
print("Fido is {} in human years".format(fido.human_age))

garfield = Cat("Garfield", 5, 4, "cat")
garfield.make_noise()

class Animal:
    def __init__(self, name, age, number_legs, animal_type):
        self.name = name
        self.age = age
        self.number_legs = number_legs
        self.animal_type = animal_type

    def make_noise(self):
        print("Rumble rumble")

class Dog(Animal):
    def __init__(self, name, age, breed):
        super(Dog, self).__init__(name, age, 4, "dog")
        self.breed = breed


fido = Dog("Fido", 5, "Labrador")

class Animal:
    def __init__(self, name, age, number_legs, animal_type):
        self.name = name
        self.age = age
        self.number_legs = number_legs
        self.animal_type = animal_type

    def make_noise(self):
        print("Rumble rumble")

class Dog(Animal):
    def __init__(self, name, age, breed):
        super(Dog, self).__init__(name, age, 4, "dog")
        self.breed = breed

    @classmethod
    def labrador(cls, name, age):
        return cls(name, age, "Labrador")

fido = Dog.labrador("Fido", 5)

print("This prints to the console/terminal!")

# notice the space at the end!
# it helps so that what you type isn't right next to the ?
name = input("What is your name? ")

# use input to get an integer
age = input("How old are you?")
# but it's still a string!
# convert it
age = int(age)

# test the length of a list or string
name_length = len(name)

# get the absolute value of a number
positive_number = abs(5 - 100)

# get the max and min of two or more numbers
num1 = 10**3
num2 = 2**5
num3 = 100003
biggest_one = max(num1, num2, num3)
smallest_one = min(num1, num2, num3)
# can do any number of variables here
#   max(num1, num2) works
#   and max(num1, num2, num3,  num4)

## max/min with a list
ages = [12, 15, 13, 10]
min_age = min(age)
max_age = max(age)

# sum over the items in a list
# more list stuff is below
ages = [12, 15, 13, 10]
sum_of_ages = sum(ages)
number_of_ages = len(ages)
average_age = sum_of_ages / number_of_ages

import pygame

class Game:

    def initialize(self):

        ## start pygame's engines
        pygame.init()

        ## get a screen
        self.screen = pygame.display.set_mode(WINDOW_SIZE)

        ## get a clock used for FPS control
        self.clock = pygame.time.Clock()

        self.example_box = pygame.Rect(0, 0, 100, 100)

    def run(self):
        ## a simple flag variable for the loop
        done = False

        ## the main game loop
        while not done:

            ### 1. Events

            ## the event loop; used to check for events that occurred since the last time around
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    done = True

            ### 2. Updates
            ## update the example box with whatever you want
            self.example_box.x += 1


            ## 3.  Drawing
            pygame.draw.rect(self.screen, BLACK, self.example_box)

            #### update the display and move forward 1 frame
            pygame.display.flip()
            # --- Limit to 60 frames per second
            self.clock.tick(FPS)