code - Mastermind_game

author__ = 'hayleyfouratt'
from graphics import *
from random import randint


g_window_width = 360
g_window_height = 700
leftmost_x = 50
palette_y = g_window_height - 50
circle_radius = 20
circle_diameter = 2 * circle_radius
h_circle_spacing = 5
v_circle_spacing = 10
exit_x = 10 + circle_radius
exit_y = 30
state_x = g_window_width - circle_radius
state_y = exit_y
circle_width = 1
secret_code_x = exit_x
#exit_x = g_window_width - circle_radius
secret_code_y = exit_y
guess_y = palette_y - 100
guess_x = leftmost_x + circle_radius + h_circle_spacing
feedback_circle_radius = 5
feedback_x = leftmost_x + 5 * circle_radius * 2 + 4 * h_circle_spacing + feedback_circle_radius
feedback_y = 540
feedback_h_spacing = 20
feedback_v_spacing = 20
secret_code_x = guess_x
secret_code_y = 150
palette_colors = ("green",  "orange", "dark blue", "yellow", "dark red", "light blue")
num_palette_colors = len(palette_colors)
center_x = 100
center_y = 150

def create_circle(center_x, center_y, radius):
    center = Point(center_x, center_y)
    circle = Circle(center, radius)
    return circle

def create_exit_circle(center_x, center_y, radius):
    exit_circle = create_circle(center_x, center_y, radius)
    exit_circle.setFill('red')
    return exit_circle

def create_state_circle(center_x, center_y, radius):
    state_circle = create_circle(center_x, center_y, radius)
    state_circle.setFill('white')
    return state_circle

def color_palette():
    color_palette[0]('green')
    color_palette[1]('orange')
    color_palette[2]('dark blue')
    color_palette[3]('yellow')
    color_palette[4]('dark red')
    color_palette[5]('light blue')
    return


def palette_circles(left_circle_center_x, left_circle_center_y, radius, palette_colors):
    palette_circle = []
    x = left_circle_center_x
    for i in range(num_palette_colors):
        circle = create_circle(x, left_circle_center_y, radius)
        circle.setFill(palette_colors[i])
        palette_circle.append(circle)
        x += circle_diameter + h_circle_spacing
    return palette_circle

def skel_circle(left_circle_center_x, left_circle_center_y, radius):
    skel = []
    x = left_circle_center_x
    for i in range(4):
        circle = create_circle(x, left_circle_center_y, radius)
        circle.setFill('white')
        skel.append(circle)
        x += circle_diameter + h_circle_spacing
    return skel

def secret_code_colors(color_palette):
    secret_colors = []
    for i in range(4):
        secret_colors.append(palette_colors[randint(0, num_palette_colors-1)])
    return secret_colors

def secret_code_circles(left_circle_center_x, left_circle_center_y, radius, secret_code):
    secret_circles = []
    x = left_circle_center_x
    for i in range(4):
        circle = create_circle(x, left_circle_center_y, radius)
        circle.setFill(secret_code[i])
        secret_circles.append(circle)
        x += circle_diameter + h_circle_spacing
    return secret_circles

def create_and_display_final_text(final_text_x, final_text_y, text_to_use):
    anchor_point = Point(final_text_x, final_text_y)
    text = Text(anchor_point, text_to_use)
    text.setSize(22)
    text.setStyle("bold")
    return text

def find_clicked_circle(click_point, list_of_circles):
    for i in range (len(list_of_circles)):
        if is_click_in_circle(click_point,list_of_circles[i]):
            return i

def is_click_in_circle(click_point, circle):
        center_x = circle.getCenter().getX()
        center_y = circle.getCenter().getY()
        radius = circle_radius
        if center_x - radius < click_point.getX() < center_x + circle_radius and\
                center_y - radius < click_point.getY() < center_y + circle_radius:
            return True
        else:
            return False

def move_circles_up(circles, dy):
    for i in range(len(circles)):
        circles[i].move(0, -dy)

def guess_is_right(guess_colors, secret_code_colors):
    if len(guess_colors) == len(secret_code_colors):
         for i in range(len(guess_colors)):
             if secret_code_colors[i] != guess_colors[i]:
                 return False
         return True
    return False


def create_feedback_skel():
    feedback_skel = []
    x = feedback_x
    for i in range(2):
            circle = create_circle(x, feedback_y, feedback_circle_radius)
            circle.setFill('white')
            feedback_skel.append(circle)
            x += (feedback_circle_radius * 2) + feedback_h_spacing
    x = feedback_x
    for i in range(2):
            circle = create_circle(x, feedback_y + feedback_h_spacing, feedback_circle_radius)
            circle.setFill('white')
            feedback_skel.append(circle)
            x += (feedback_circle_radius * 2) + feedback_v_spacing
    return feedback_skel

def create_feedback_circles(secret_code_colors, guess_code_colors, feedback_skel_circles):
    feedback_circles = []
    guess_color_used = [False, False, False, False]
    secret_color_used = [False, False, False, False]
    feedback_idx = 0
    for i in range(4):
        if secret_code_colors[i] == guess_code_colors[i]:
            guess_color_used[i] = secret_color_used[i] = True
            c = feedback_skel_circles[feedback_idx].clone()
            feedback_idx += 1
            c.setFill('red')
            feedback_circles.append(c)
    for i in range(4):
        if not guess_color_used[i]:
            for j in range(4):
                if not secret_color_used[j] and secret_code_colors[j] == guess_code_colors[i]:
                    c = feedback_skel_circles[feedback_idx].clone()
                    c.setFill('white')
                    feedback_circles.append(c)
                    feedback_idx += 1
                    secret_color_used[j] = True
                    break
    return feedback_circles

def main():
    win = GraphWin('Animation', 380, 700, autoflush=False)
    #win = GraphWin('Animation', 700, 700, autoflush=False)

    count = 0
    center_x = 100
    center_y = 100
    left_circle_center_x = 100
    left_circle_center_y = 100

    #create_circle(Point(center_x, center_y), circle_radius)
    #create_circle.draw(win)

    exit_circle = create_exit_circle(exit_x, exit_y, circle_radius)
    exit_circle.draw(win)

    state_circle = create_state_circle(state_x, state_y, circle_radius)
    state_circle.draw(win)

    palette_circle = palette_circles(leftmost_x, palette_y, circle_radius, palette_colors)
    for i in range(len(palette_circle)):
        palette_circle[i].draw(win)


    skel_circles = skel_circle(guess_x, guess_y, circle_radius)
    for i in range(len(skel_circles)):
        skel_circles[i].draw(win)

    secret_colors = secret_code_colors(palette_colors)
    secret_circles = secret_code_circles(secret_code_x, secret_code_y, circle_radius, secret_colors)
    for i in range(len(secret_circles)):
        secret_circles[i].draw(win)
    feedback_skel = create_feedback_skel()
    for i in range(8):
        guess_colors = [None, None, None, None]
        for j in range(4):
            click_point = win.getMouse()
            if is_click_in_circle(click_point, exit_circle):
                win.close()
                return
            if find_clicked_circle(click_point, palette_circle) is not None:
                idx = find_clicked_circle(click_point, palette_circle)
                state_circle.setFill(palette_colors[idx])
            click_point = win.getMouse()
            if find_clicked_circle(click_point, skel_circles) is not None:
                idx2 = find_clicked_circle(click_point, skel_circles)
                guess_colors[idx2] = palette_colors[idx]
                circle = skel_circles[idx2].clone()
                circle.setFill(palette_colors[idx])
                circle.draw(win)
                state_circle.setFill('white')
        feedback_circles = create_feedback_circles(secret_colors, guess_colors, feedback_skel)
        for k in range(len(feedback_circles)):
            feedback_circles[k].draw(win)
        move_circles_up(skel_circles, circle_diameter + v_circle_spacing)
        move_circles_up(feedback_skel, circle_diameter + v_circle_spacing)

    if guess_is_right:
        text = create_and_display_final_text(180, exit_y + 60, "You Win")
        print(text)
    else:
        text = create_and_display_final_text(180, exit_y + 60, "You Lose")
        print(text)
    text.draw(win)

    mouse_click = win.getMouse()
    win.getMouse()
    win.close()
main()

function - create_rectangle

def draw_rectangle(top_left_x, top_left_y, width, height, color):

    point = Point(top_left_x, top_left_y)
    point2 = Point(top_left_x + width, top_left_y + height)
    rectangle = Rectangle(point, point2)
    rectangle.draw(window)
    rectangle.setOutline('red')
    rectangle.setFill(color)

function - create_circle

def main():
    radius = 20
    diameter = 2 * radius
    v_distance_between_ball_centers = 100
    bottom_ball_initial_y = 500
    x_ball_center = 250
    win = GraphWin('Animation', 600, 600, autoflush=False)

    c1_center = Point(x_ball_center, bottom_ball_initial_y)
    c1 = Circle(c1_center, radius)
    c1.setFill('blue')
    c1.draw(win)

function - matrix/array

def create_matrix(square_size):
    array = []
    for i in range(square_size):
        array.append([])
        for j in range(square_size):
            array[i].append(0)
    return array