Introduction-to-Interactive-Python/memory.py at master · timvan/Introduction-to-Interactive-Python · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
# http://www.codeskulptor.org/#user40_XafP3nf8T6NHUiT_7.py
# implementation of card game - Memory

import simplegui
import random

L_x = 100
L_y= 1.4 * L_x
card_size = [L_x, L_y]
bord = 5

card_x = 10
card_y = 1

frame_size = [card_size[0] * card_x, card_size[1] * card_y]


# helper function to initialize globals
def new_game():
    global state, turns, exposed, card_list, card_last, card_last2, card_x, card_y
    state = 0
    turns = 0

    num_cards = card_x * card_y
    exposed = [False]*card_x*card_y

    card_last = [None, None]
    card_last2 = [None, None]

    card_list = range(1, num_cards // 2 + 1) + range(1, num_cards // 2 + 1)
    random.shuffle(card_list)
    label.set_text("Turns = " + str(turns))


def add_pairs():
    global card_x, card_y, num_cards

    card_y += 1

    frame_size = [card_size[0] * card_x, card_size[1] * card_y]
    frame = simplegui.create_frame("Memory", frame_size[0], frame_size[1])
    frame.add_button("Reset", new_game)
    label = frame.add_label("Turns = 0")
    frame.add_button("Add Pairs", add_pairs)
    frame.add_button("Reduce Pairs", reduce_pairs)
    frame.set_mouseclick_handler(mouseclick)
    frame.set_draw_handler(draw)
    new_game()
    frame.start()


def reduce_pairs():
    global card_x, card_y, num_cards

    if card_y > 1:
        card_y -= 1

    frame_size = [card_size[0] * card_x, card_size[1] * card_y]
    frame = simplegui.create_frame("Memory", frame_size[0], frame_size[1])
    frame.add_button("Reset", new_game)
    label = frame.add_label("Turns = 0")
    frame.add_button("Add Pairs", add_pairs)
    frame.add_button("Reduce Pairs", reduce_pairs)
    frame.set_mouseclick_handler(mouseclick)
    frame.set_draw_handler(draw)
    new_game()
    frame.start()

# define event handlers
def mouseclick(pos):
    # add game state logic here
    global exposed, state, card_last, card_last2, turns, card_list, card_x, card_y

    if pos[0] % L_x > bord and pos[0] % L_x < L_x-bord:
        if pos[1] % L_y > bord and pos[1] % L_y < L_y-bord:
            x_e = pos[0] // L_x
            y_e = pos[1] // L_y

            if exposed[x_e + (y_e * card_x)]:
                pass

            else:
                exposed[x_e + (y_e * card_x)] = True

                if state == 0:
                    card_last2 = list(card_last)
                    card_last = [x_e, y_e]
                    state = 1

                elif state == 1:
                    if card_list[card_last[0] + (card_last[1] * card_x)] == card_list[x_e + (y_e * card_x)]:
                        turns += 1
                        card_last2 = [None, None]
                        card_last = [None, None]
                        state = 0
                    else:
                        card_last2 = list(card_last)
                        card_last = [x_e, y_e]
                        state = 2
                        turns += 1
                else:
                    exposed[card_last2[0] + (card_last2[1] * card_x)] = False
                    exposed[card_last[0] + (card_last[1] * card_x)] = False
                    state = 1
                    card_last2 = [None, None]
                    card_last = [x_e, y_e]

                label.set_text("Turns = " + str(turns))


# cards are logically 50x100 pixels in size
def draw(canvas):

    for x in range(card_x):
        for y in range(card_y):
                canvas.draw_polygon(
                    [[bord + x*L_x, bord + y*L_y],
                    [card_size[0]-bord + x*L_x, bord + y*L_y],
                    [card_size[0]-bord + x*L_x, card_size[1]-bord + y*L_y],
                    [bord + x*L_x, card_size[1]-bord + y*L_y]],
                    2, "Red", "White")

    for x in range(card_x):
        for y in range(card_y):
            if card_list[x + (y * card_x)] > 9:
                canvas.draw_text(str(card_list[x + (y * card_x)]),
                             (L_x*(x + 0.22), L_y*(y + 0.55)),
                             50, "Black")
            else:
                canvas.draw_text(str(card_list[x + (y * card_x)]),
                             (L_x*(x + 0.35), L_y*(y + 0.55)),
                             50, "Black")

    for x in range(card_x):
        for y in range(card_y):
            if not exposed[x + (y * card_x)]:
                canvas.draw_polygon(
                    [[bord + x*L_x, bord + y*L_y],
                    [card_size[0]-bord + x*L_x, bord + y*L_y],
                    [card_size[0]-bord + x*L_x, card_size[1]-bord + y*L_y],
                    [bord + x*L_x, card_size[1]-bord + y*L_y]],
                    2, "White", "Red")


# create frame and add a button and labels
frame = simplegui.create_frame("Memory", frame_size[0], frame_size[1])
frame.add_button("Reset", new_game)
label = frame.add_label("Turns = 0")

frame.add_button("Add Row", add_pairs)
frame.add_button("Reduce Row", reduce_pairs)

# register event handlers
frame.set_mouseclick_handler(mouseclick)
frame.set_draw_handler(draw)

# get things rolling
new_game()
frame.start()


# Always remember to review the grading rubric