# create an integer
x = 5

# convert an integer string
x = str('5')

# convert a float to an integer
## note: don't depend on this for rounding, it rounds in weird ways
x = int(5.5)

# convert a string of any number base
# for example, binary
x = int('1010101', base=2)

# create a float
x = 5.5

# convert a float string
x = float("5.5")

# convert an integer to a float
x = float(5)

x = 100

# 1. Add
x = x + 5
x += 5

# 2. Subtract
x = x - 5
x -= 5

# 3. Multiply
x = x * 5
x *= 5

# 4. Divide
x = x / 5
x /= 5

# 5. Power
x = x ** 2
x **= 2

# 1. Integer Division
x = x // 5
x //= 5

# 2. Modulo
x = 84
x = x % 5
x %= 5

import math

x = 10

# pow is power, same as x ** 2
x = math.pow(x, 2)

# ceil rounds up and floor rounds down
x = 5.5
y = math.ceil(x) # y is 6.0
z = math.floor(x) # z in 5.0

# some other useful ones:
math.sqrt(x)
math.cos(x)
math.sin(x)
math.tan(x)

# this will give you pi:
math.pi

first_name = "euclid "
space = " "
last_name = "von rabbitstein"
full_name = first_name + space + last_name

message = "Repeat me!"
repeated10 = message * 10

# I like to use it for pretty printing code results
line = "-" * 12
print("   Title!   ")
print(line)

first_name = "Euclid"
last_name = "Von Rabbitstein"
first_initial = first_name[0]
last_initial = last_name[0]
initials = first_initial + last_initial

# the syntax is
#   my_string[start:stop]
# this includes the start position but goes UP TO the stop
# you can leave either empty to go to the front or end

target = "door"
last_three = target[1:]
first_three = target[:3]
middle_two = target[1:3]

# you can use negatives to slice off the end!
all_but_last = target[:-1]

pig_latin = target[1:] + target[0] + "ay"

full_name = "euclid von Rabbitstein"

# all caps
full_name_uppered = full_name.upper()

# all lower
full_name_lowered = full_name.lower()

# use lower to make sure something is lower before you compare it
user_command = "Exit"
if user_command.lower() == "exit":
    print("now I can exit!")

# first letter capitalized
full_name_capitalized = full_name.capitalize()

# split into a list
full_name_list = full_name.split(" ")

# strip off any extra spaces
test_string = "   extra spaces everywhere   "
stripped_string = test_string.strip()

# replace things in a string
full_name_replaced = full_name.replace("von", "rabbiticus")

# use replace to delete things from a string!
test_string = "annoying \t tabs in \t the string"
fixed_string = test_string.replace("\t","")

literal_boolean = True
other_one = False

x = 9
y = 3
x_is_bigger = x > y # True
x_is_even = x % 2 == 0 # False
x_is_multiple_of_y = x % y == 0 # True

# example data
card_suit = "Hearts"
card_number = 7

# save the results from comparisons!
card_is_hearts = card_suit == "Hearts"
card_is_diamond = card_suit == "Diamond"
card_is_big = card_number > 8

# only 1 of them needs to be true
card_is_red = card_is_hearts or card_is_diamond

# both need to be true
card_is_good = card_is_red and card_is_big

# creates the opposite!
card_is_bad = not card_is_good

power_level = 1000
min_power_level = 500
max_power_level = 1000

# one thing is larger than another
if power_level > minimum_power_level:
    print("We have enough power!")

if power_level == max_power_level:
    print("You have max power!")

selected_option = 2

if selected_option == 1:
    print("Doing option 1")
elif selected_option == 2:
    print("Doing option 2")
elif selected_option == 3:
    print("doing option 3")
else:
    print("Doing the default option!")

name = "euclid"
animal = "bunny"

if animal == "bunny":
    if name == "euclid":
        print("Euclid is my bunny")
    elif name == "leta":
        print("Leta is my bunny")
    else:
        print("this is not my bunny..")
else:
    print("Not my animal!")

new_list = list()
# or
new_list = []

my_pets = ['euclid', 'leta']

my_pets.append('socrates')

first_pet = my_pets[0]
second_pet = my_pets[1]
third_pet = my_pets[2]

# the syntax is
#   my_list[start:stop]
# this includes the start position but goes UP TO the stop
# you can leave either empty to go to the front or end

first_two_pets = my_pets[:2]
last_two_pets = my_pets[1:]

## with any collection, you can test if an item is inside the collection
## it is with the "in" keyword

my_pets = ['euclid', 'leta']
if 'euclid' in my_pets:
    print("Euclid is a pet!")

my_pet_list = ['euclid', 'leta']

# you can convert lists to sets using the set keyword
my_pet_set = set(my_pet_list)

# sets are like lists but you can't index into them or slice them
# they are used for fast membership testing

# you can create a new set by:
my_pet_set = set(['euclid', 'leta'])

my_new_set = set()

# instead of append, like a list, you use 'add'
my_new_set.add("Potatoes")

my_grocery_list = ['potatoes', 'cucumbers', 'potatoes']

# now if you want to make sure items only appear once, you can convert it to a set
# it will automatically do this for you, because items are only allowed to be in sets one time

my_grocery_set = set(my_grocery_list)

for i in range(10):
    print("do stuff here")

for i in range(10):
    new_number = i * 100
    print("The loop variable is i.  It equals {}".format(i))
    print("I used it to make a new number. That number is {}".format(new_number))

start = 3
stop = 10
step = 2

for i in range(stop):
    print(i)

for i in range(start, stop):
    print(i)

for i in range(start, stop, step):
    print(i)

my_pets = ['euclid', 'leta']

for pet in my_pets:
    print("One of my pets: {}".format(pet))

for i in range(4):
    for j in range(4):
        result = i * j
        print("{} times {} is {}".format(i, j, result))

response = ""

while response != "exit":
    print("Inside the loop!")
    response = input("Please provide input: ")

done = False

while not done:
    print("Inside the loop!")
    response = input("Please provide input: ")
    if response == "exit":
        done = True

while True:
    print("Don't do this!  It is a bad idea.")

for i in range(100):
    if i < 90:
        continue
    else:
        print("At number {}".format(i))

while True:
    response = input("Give me input: ")
    if response == "exit":
        break

def say_hello():
    print("hello!")

def say_something(the_thing):
    print(the_thing)

def double(x):
    return 2*x

def exp_func(x, y):
    result = x ** y
    return result

final_number = exp_func(10, 3)

def say_many_times(message, n=10):
    for i in range(n):
        print(message)

say_many_times("Hi!", 2)
say_many_times("Yay!", 10)

import time

start = time.time()

for i in range(10000):
    continue

new_time = time.time()
total_time = new_time - start
print(total_time)

import time

start = time.time()

time.sleep(10)

end = time.time()

print(start - end)

import random

num = random.random()
print("the random number is {}".format(num))

import random

num = random.randint(5, 100)
print("the random integer between 5 and 100 is {}".format(num))

import random

my_pets = ['euclid', 'leta']
fav_pet = random.choice(my_pets)
print("My randomly chosen favorite pet is {}".format(fav_pet))

r1.center = (50,50)
r1.right = 10
r1.bottomright = 75

# W, H are window width and window height

if r1.right > W:
    print("Over right side")
elif r1.left < 0:
    print("over left side")

if r1.top < 0:
    print("Over top")
elif r1.bottom > H:
    print("Over bottom")

# W, H are window width and window height
r1.x += dx

if r1.right > W or r1.left < 0:
    dx *= -1

r1.y += dy
if r1.top < 0 or r1.bottom > H:
    dy *= -1

'''
in this example, self.rect is the rect of the object you are moving
'''


def move(self, dx, dy, other_rects):

    # move this object in the x direction
    self.rect.x += dx

    # go over each obstacle
    for other_rect in other_rects:


        # if there is a collision
        # since we moved only the x, we know it has to be this object's left or right
        if self.rect.colliderect(other_rect):

            # if dx is positive, it is moving right
            # if the right side is past the other rect's left, snap them together
            if dx > 0 and self.rect.right > other_rect.left:
                self.rect.right = other_rect.left

            # if dx is negative, it is moving left
            # if the left side is past the other rect's right, snap them together
            elif dx < 0 and self.rect.left < other_rect.right:
                self.rect.left = other_rect.right


    # move this object in the y direction
    self.rect.y += dy

    # go over each obstacle
    for other_rect in other_rects:

        # if there is a collision
        # since we moved only the y, we know it has to be this object's top or bottom
        if self.rect.colliderect(other_rect):

            # if dy is positive, it is moving down
            # if the bottom is past the other rect's top, snap them together
            if dy > 0 and self.rect.bottom > other_rect.top:
                self.rect.bottom = other_rect.top

            # if dy is negative, it is moving up
            # if the top is past the other rect's bottom, snap them together
            elif dy < 0 and self.rect.top < other_rect.bottom:
                self.rect.top = other_rect.bottom

class BasicSprite(pygame.sprite.Sprite):

    # by defining this function, we are overriding the parent class's function
    def __init__(self, color, width, height):

        # this is a special command which tells python to execute the parent's function
        # the pattern is
        # super(ThisClassName, self).func_to_call()
        super(BasicSprite, self).__init__()

        ### When you sublcass the sprite, you need two things

        #  1. self.image

        self.image = pygame.Surface([width, height])
        self.image.fill(color)

        #  2. self.rect

        self.rect = self.image.get_rect()

        # self.rect starts out at 0,0. if you want to change the location, you have to update these coordinates
        # this hard codes the BasicSprite to start at the coordinates 50,50
        self.rect.x = 50
        self.rect.y = 50

class Game:

    def initialize(self):
        # other code was here

        # just remember that our screen is made here
        self.screen = pygame.display.set_mode(WINDOW_SIZE)

        self.example_object = BasicSprite(BLACK, 100, 100)

    def run(self):
        done = False

        ## the main game loop
        while not done:

            # other code was here


            ## the way to read this dot notation is:
            ## inside this Game object access (using "self") a variable called example_object
            ## inside example_object is the property "image" (which we defined just above)
            ## inside image is a function called blit
            ## blit takes two arguments:
            ##      1. the surface it should draw on, this is our screen.
            ##      2. the coordinates of where to draw it. this is the rect inside example_object
            ## overall, the syntax is:
            ##      surface_variable.blit(screen_variable, rect_variable)

            self.example_object.image.blit(self.screen, self.example_object.rect)


            ## then don't forget the rest of the code here

class BasicSprite(pygame.sprite.Sprite):

    # by defining this function, we are overriding the parent class's function
    def __init__(self, color=BLACK, width=100, height=100):
        # notice it has default values for its paremeters!

        # this is a special command which tells python to execute the parent's function
        # the pattern is
        # super(ThisClassName, self).func_to_call()
        super(BasicSprite, self).__init__()

        ### When you sublcass the sprite, you need two things

        #  1. self.image

        self.image = pygame.Surface([width, height])
        self.image.fill(color)

        #  2. self.rect

        self.rect = self.image.get_rect()

        # self.rect starts out at 0,0. if you want to change the location, you have to update these coordinates
        # this hard codes the BasicSprite to start at the coordinates 50,50
        self.rect.x = 50
        self.rect.y = 50



    def draw(self, screen):
        # draw this object's image onto the passed in screen variable
        self.image.blit(self.screen, self.rect)

class MovingSprite(BasicSprite):
    # MovingSprite has all the functions and properties that
    # BasicSprite has

    def move(self, dx, dy):
        ## move dx units in the x direction
        ## move dy units in the y direction

        self.rect.x += dx
        self.rect.y += dy

class MovingSprite(BasicSprite):
    # MovingSprite has all the functions and properties that
    # BasicSprite has
    def __init__(self, color=BLACK, width=100, height=100):
        super(MovingSprite, self).__init__(color, width, height)

        self.dx = 0
        self.dy = 0

    def move(self):
        ## move dx units in the x direction
        ## move dy units in the y direction

        self.rect.x += self.dx
        self.rect.y += self.dy

class CollisionSprite(BasicSprite):
    # CollisionSprite has all the functions and properties that
    # BasicSprite has, which has all of the functions BasicSprite has!


    def handle_collision(self, other_sprite, dx, dy):
        # we are going to define the logic for handling the collision with
        # one other sprite

        # there are two extra variables this function is taking.
        # they are the dx and dy. we need these so we know which direction
        # the sprite is moving!
        # Note: we want to make sure we only move x or y.
        # if we are moving both, then we don't know whether the collision
        # is from the top/bottom or from the sides.

        if dx != 0 and dy != 0:
            # this syntax is:
            #   "raise" is a way of manually throwing errors and exceptions
            #   "Exception" is the default exception
            # by doing
            #   raise Exception(some_message)
            # we are stopping the program and causing an error.
            raise Exception("ERROR: don't move both x and y at the same time; Collision checking is impossible if you do this!")


        if pygame.sprite.collide_rect(self, other_sprite):
            ## if this "if" is true, then this means a collision is happening!
            ## let's check and see which direction it is

            ## check if the sprite is moving in the x direction:
            # if dx is positive, it is moving right
            # if the right side is past the other rect's left, snap them together
            if dx > 0 and self.rect.right > other_sprite.rect.left:
                self.rect.right = other_sprite.rect.left

            # if dx is negative, it is moving up
            # if the left side is past the other rect's right, snap them together
            elif dx < 0 and self.rect.left < other_sprite.rect.right:
                self.rect.left = other_sprite.rect.right

            # if dy is positive, it is moving down
            # if the bottom is past the other rect's top, snap them together
            if dy > 0 and self.rect.bottom > other_sprite.rect.top:
                self.rect.bottom = other_sprite.rect.top

            # if dy is negative, it is moving up
            # if the top is past the other rect's bottom, snap them together
            elif dy < 0 and self.rect.top < other_sprite.rect.bottom:
                self.rect.top = other_sprite.rect.bottom





    ## Let's re-write the move function from before to handle collisions
    def move(self, other_sprite=None):
        ## we will assume that we are given access to a single other sprite
        ## as an argument to this function
        ## we will give it a default value of None though, so it's only optional

        ## move dx units in the x direction
        self.rect.x += self.dx

        if other_sprite is not None:
            # handle the x collision!
            self.handle_collision(other_sprite, self.dx, 0)

        ## move dy units in the y direction
        self.rect.y += self.dy

        if other_sprite is not None:
            # handle the y collision!
            self.handle_collision(other_sprite, 0, self.dy)

class Game:

    def initialize(self):
        # other code was here

        # just remember that our screen is made here
        self.screen = pygame.display.set_mode(WINDOW_SIZE)

        ## use group to manage a list of basic sprites
        self.basic_sprites = pygame.sprite.Group()

        # let's create a couple basic sprites
        for i in range(5):
            # create the new sprite
            # notice no self variable
            # that's because I know I'm not saving this inside self
            # instead, I'm saving this inside self.basic_sprites
            new_sprite = BasicSprite(BLACK, 100, 100)

            # doing this to offset the sprites so we can see them
            new_sprite.rect.x += i * 50
            new_sprite.rect.y += i * 50

            # save it to self.basic_sprites
            self.basic_sprites.add(new_sprite)


    def run(self):
        done = False

        ## the main game loop
        while not done:

            # other code was here

            # because you used a group to handle the basic sprites, you
            # can shortcut the drawing of them by using group's draw function:

            self.basic_sprites.draw(self.screen)

class GroupCollisionSprite(CollisionSprite):
    # CollisionSprite has all the functions and properties that
    # CollisionSprite has, which has all of the functions CollisionSprite has!

    def handle_group_collision(self, sprite_group, dx, dy):
        # we pass in the "sprite_group", and the movements again

        # the False here is the option to remove all sprites being collided with
        # from the group.
        # if True, sprite_group will no longer have them and they won't be drawn anymore
        # the returned object, colliding_sprites, is a list of sprites!
        colliding_sprites = pygame.sprite.spritecollide(self, sprite_group, False)

        # go through each of the sprites in this list
        for sprite in colliding_sprites:

            # use the function from CollisionSprite to handle this!

            self.handle_collision(sprite, dx, dy)



    ## Let's re-write the move function from before to handle group collisions
    def move(self, collision_group=None):
        ## we will assume that we are given access to a single other sprite
        ## as an argument to this function
        ## we will give it a default value of None though, so it's only optional

        ## move dx units in the x direction
        self.rect.x += self.dx

        # make sure it's not the default value
        if collision_group is not None:
            # handle the x collision!
            self.handle_group_collision(collision_group, self.dx, 0)

        ## move dy units in the y direction
        self.rect.y += self.dy

        # make sure it's not the default value
        if collision_group is not None:
            # handle the y collision!
            self.handle_group_collision(collision_group, 0, self.dy)

class Game:

    def initialize(self):
        # other code was here

        # just remember that our screen is made here
        self.screen = pygame.display.set_mode(WINDOW_SIZE)

        ## use group to manage a list of basic sprites
        self.basic_sprites = pygame.sprite.Group()

        # let's create a couple basic sprites
        for i in range(5):
            # create the new sprite
            # notice no self variable
            # that's because I know I'm not saving this inside self
            # instead, I'm saving this inside self.basic_sprites
            new_sprite = BasicSprite(BLACK, 100, 100)

            # doing this to offset the sprites so we can see them
            new_sprite.rect.x += i * 50
            new_sprite.rect.y += i * 50

            # save it to self.basic_sprites
            self.basic_sprites.add(new_sprite)


        # it has the same __init__ function as BasicSprite
        self.hero = GroupCollisionSprite(BLACK, 100, 100)



    def run(self):
        done = False

        ## the main game loop
        while not done:

            # other code was here

            # remember the loop order:
            # Events, Updates, and then Draw

            # Updates is where collisions and movement goes
            # let's move the hero and have it handle sprite collision!
            self.hero.move(self.basic_sprites)

            # because you used a group to handle the basic sprites, you
            # can shortcut the drawing of them by using group's draw function:

            self.basic_sprites.draw(self.screen)
            self.hero.draw(self.screen)

class ImageSprite(GroupCollisionSprite):

    def __init__(self, image_filename, colorkey=WHITE):

        # because all of the arguments in BasicSprite were optional, we
        # can just call the init function
        super(ImageSprite, self).__init__()

        # now, we overwrite image
        self.image = pygame.image.load(image_filename).convert()

        # Set our transparent color
        self.image.set_colorkey(colorkey)

        # refresh the rect now
        self.rect = self.image.get_rect()

class Game:




    def run(self):
        done = False

        ## the main game loop
        while not done:

            ## the event loop

            ## 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
                else:
                    # if the event isn't a quitting event, give it to the hero!
                    self.hero.handle_event(event)