--- /dev/null
+import pygame
+import math
+import time
+import random
+
+
+def format_number(num):
+ if num < 1000:
+ return num
+
+ out = ""
+ for i, val in enumerate((str(num)[::-1])):
+ out += val
+ if (i + 1) % 3 == 0 and i != len(str(num)) - 1:
+ out += ","
+ out = out[::-1]
+
+ return out
+
+
+def deg2rad(angle):
+ pi = 3.14
+ return angle * pi / 180
+
+
+def increase_score_base():
+ global score_base, base_cost, score
+ score_base += 1
+ score -= base_cost
+ out = 3 * 1.15 ** score_base
+ return int(out)
+
+
+def increase_score_multiplier():
+ global score_multiplier, multiplier_cost, score
+ score_multiplier += 1
+ score -= multiplier_cost
+ out = 5 * 1.75 ** score_multiplier
+ return int(out)
+
+
+def increase_autoclicker():
+ global autoclicker, autoclicker_cost, score
+ autoclicker += 1
+ score -= autoclicker_cost
+ out = 50 * 2.15 ** autoclicker
+ return int(out)
+
+
+class Cookie:
+ radius = 100
+ # colour = (255, 255, 0)
+ cookie_image = pygame.image.load("cookie.png")
+
+ def __init__(self, x, y):
+ self.position = pygame.Vector2(x, y)
+
+ self.transform(self.radius * 2)
+ self.grow_factor = 1.1
+ self.is_scaled = False
+ # min_chocolate_chips = 5
+ # max_chocolate_chips = 10
+ # self.chocolate_chips = [self.add_chocolate_chips() for i in
+ # range(random.randint(min_chocolate_chips, max_chocolate_chips))]
+
+ def transform(self, size):
+ self.image = pygame.image.load("cookie.png")
+ self.image = pygame.transform.scale(self.image, (int(size), int(size)))
+ self.width = self.image.get_width()
+ self.height = self.image.get_height()
+ self.centering = pygame.Vector2(self.width / 2, self.height / 2)
+
+ def add_chocolate_chips(self):
+ direction = deg2rad(random.randint(0, 360))
+ magnitude = random.randint(0, int(self.radius * 3 / 4))
+ return pygame.Vector2(magnitude * math.cos(direction), magnitude * math.sin(direction))
+
+ def is_touching_mouse_pointer(self):
+ mouse_x, mouse_y = pygame.mouse.get_pos()
+ if math.sqrt((self.position.x - mouse_x) ** 2 + (self.position.y - mouse_y) ** 2) <= self.radius:
+ return True
+ return False
+
+ # def lighten(self):
+ # darken_percent = .50
+ # dark = pygame.Surface(self.image.get_size()).convert_alpha()
+ # dark.fill((0, 0, 0), darken_percent * 0)
+ # self.image.blit(dark, (0, 0))
+
+ # def darken(self):
+ # darken_percent = .50
+ # dark = pygame.Surface(self.image.get_size()).convert_alpha()
+ # dark.fill((0, 0, 0, darken_percent * 255))
+ # self.image.blit(dark, (0, 0))
+ # self.image.set_alpha(225)
+
+ def update(self, delta, limit_x):
+ if self.is_touching_mouse_pointer():
+ self.transform(self.grow_factor * self.radius * 2)
+ self.is_scaled = True
+ elif self.is_scaled:
+ self.transform(self.radius * 2)
+ self.is_scaled = False
+
+ def draw(self, surface):
+ surface.blit(self.image, self.position - self.centering)
+
+ # pygame.draw.circle(surface, self.colour, self.position, self.radius, width=0)
+
+ # for chip in self.chocolate_chips:
+ # pygame.draw.circle(surface, (0, 0, 0), self.position + chip, self.radius / len(self.chocolate_chips),
+ # width=0)
+
+
+class FallingCookie(Cookie):
+ radius = 40
+ gravity = 5
+
+ def __init__(self):
+ temp = self.reset()
+ super().__init__(temp[0], temp[1])
+
+ def reset(self):
+ return pygame.Vector2(random.randint(self.radius, SCREEN_WIDTH - self.radius),
+ -random.randint(0, SCREEN_HEIGHT * 2) - self.radius)
+
+ def update(self, delta, limit_x):
+ self.position.y += self.gravity * delta / 50
+ if self.position.y - self.radius > SCREEN_HEIGHT:
+ self.position = self.reset()
+ if self.position.x <= limit_x + self.radius + Rectangle.horizontal_padding:
+ self.position = self.reset()
+
+
+class CPSCounter:
+ click_counter = 0
+ clicks = []
+ start_time = time.time()
+ cps = 0
+ highest_cps = 0
+
+ def __init__(self):
+ self.cps_label_text = [f"CPS: {self.cps}"]
+ self.cps_label = Label(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2 + Cookie.radius + Label.vertical_padding,
+ self.cps_label_text, 25, text_colour=(20, 20, 20))
+
+ def add_click(self):
+ self.clicks.append(time.time() - self.start_time)
+ self.clear_clicks()
+
+ def clear_clicks(self):
+ del_counter = 0
+ latest = self.clicks[-1]
+ for pos, val in enumerate(self.clicks):
+ if latest - val > 1:
+ del self.clicks[pos - del_counter]
+ del_counter += 1
+ else:
+ break
+
+ @staticmethod
+ def find_range(lis): # lis for list input
+ if len(lis) > 0:
+ return lis[-1] - lis[0]
+ else:
+ return 0
+
+ def update(self, delta):
+ self.cps = len(self.clicks)
+ self.highest_cps = max(self.highest_cps, self.cps)
+ for i in range(len(self.clicks)):
+ if self.find_range(self.clicks) > 1 or (
+ self.cps > 0 and time.time() - self.start_time - self.clicks[-1] > 1):
+ del self.clicks[0]
+ else:
+ break
+ self.cps_label_text = [f"CPS: {self.cps}"]
+ self.cps_label.update(delta, self.cps_label_text)
+
+ def draw(self, surface):
+ self.cps_label.draw(surface)
+
+
+class Label:
+ horizontal_padding = 5
+ vertical_padding = 5
+ outline_thickness = 2
+
+ def __init__(self, x, y, text, font_size, text_colour=(0, 0, 0), antialias=True, fill_colour=(150, 150, 150),
+ outline_colour=(0, 0, 0)):
+ self.position = pygame.Vector2(x, y)
+ self.font = pygame.font.Font("MontserratBlack-ZVK6J.otf", font_size)
+ self.text_colour = text_colour
+ self.antialias = antialias
+ self.fill_colour = fill_colour
+ self.outline_colour = outline_colour
+ self.text, self.width, self.height = self.create_text(text)
+ self.centering = pygame.Vector2(0, 0)
+
+ def create_text(self, text):
+ out = []
+ max_width = 0
+ max_height = 0
+ for line in text:
+ text_surface = self.font.render(line, self.antialias, self.text_colour)
+ width = text_surface.get_width()
+ height = text_surface.get_height()
+ out.append((text_surface, width, height))
+ max_width = max(max_width, width)
+ max_height += height
+ return out, max_width, max_height
+
+ def update(self, delta, new_text=None, x=None, y=None, width=None, height=None, colour=None):
+ if new_text is not None:
+ self.text, self.width, self.height = self.create_text(new_text)
+ if x is not None:
+ self.position.x = x
+ if y is not None:
+ self.position.y = y
+ if width is not None:
+ self.width = width
+ if height is not None:
+ self.height = height
+ if colour is not None:
+ self.fill_colour = colour
+
+ def draw(self, surface, centered_x=True, centered_y=True, outlined=False, filled=False):
+ if centered_x:
+ self.centering.x = self.width / 2
+ if centered_y:
+ self.centering.y = self.height / 2
+ if filled:
+ r = pygame.Rect(
+ self.position - pygame.Vector2(self.horizontal_padding, self.vertical_padding) - self.centering,
+ pygame.Vector2(self.width + 2 * self.horizontal_padding,
+ self.height + self.vertical_padding * 2))
+ pygame.draw.rect(surface, self.fill_colour, r)
+ if outlined:
+ r = pygame.Rect(
+ self.position - pygame.Vector2(self.horizontal_padding, self.vertical_padding) - self.centering,
+ pygame.Vector2(self.width + 2 * self.horizontal_padding,
+ self.height + self.vertical_padding * 2))
+ pygame.draw.rect(surface, self.outline_colour, r, self.outline_thickness)
+
+ prev_height = 0
+ for line in self.text:
+ text_surface, width, height = line
+ surface.blit(text_surface, self.position - self.centering + pygame.Vector2(0, prev_height))
+ prev_height += height
+
+
+class Button(Label):
+
+ def __init__(self, x, y, text, font_size, text_colour=(0, 0, 0), antialias=True, fill_color=(150, 150, 150),
+ outline_colour=(0, 0, 0)):
+ super().__init__(x, y, text, font_size, text_colour=text_colour, antialias=antialias, fill_colour=fill_color,
+ outline_colour=outline_colour)
+
+ def is_touching_mouse_pointer(self):
+ mouse_x, mouse_y = pygame.mouse.get_pos()
+ if (self.position.x - self.centering.x <= mouse_x <= self.position.x + self.width - self.centering.x
+ and self.position.y - self.centering.y <= mouse_y <= self.position.y + self.height - self.centering.y):
+ return True
+ return False
+
+ def lighten(self):
+ self.fill_colour = (100, 100, 100)
+
+ def darken(self):
+ self.fill_colour = (150, 150, 150)
+
+ def update(self, delta, new_text=None, x=None, y=None, width=None, height=None, colour=None):
+ super().update(delta, new_text=new_text, x=x, y=y, width=width, height=height, colour=colour)
+ if self.is_touching_mouse_pointer():
+ self.lighten()
+ else:
+ self.darken()
+
+ def run_function(self, function):
+ return function()
+
+
+class Rectangle:
+ horizontal_padding = 12
+ vertical_padding = 12
+ outline_colour = (40, 40, 40)
+ outline_thickness = 5
+
+ def __init__(self, x, y, width, height, colour):
+ self.position = pygame.Vector2(x, y)
+ self.width = width
+ self.height = height
+ self.fill_colour = colour
+ self.centering = pygame.Vector2(0, 0)
+
+ def update(self, x=None, y=None, width=None, height=None, colour=None):
+ if x is not None:
+ self.position.x = x
+ if y is not None:
+ self.position.y = y
+ if width is not None:
+ self.width = width
+ if height is not None:
+ self.height = height
+ if colour is not None:
+ self.fill_colour = colour
+
+ def draw(self, surface, centered_x=True, centered_y=True, outlined=True):
+ if centered_x:
+ self.centering.x = self.width / 2
+ if centered_y:
+ self.centering.y = self.height / 2
+ if outlined:
+ r = pygame.Rect(
+ self.position - pygame.Vector2(self.horizontal_padding, self.vertical_padding) - self.centering,
+ pygame.Vector2(self.width + 2 * self.horizontal_padding,
+ self.height + self.vertical_padding))
+ pygame.draw.rect(surface, self.outline_colour, r, self.outline_thickness)
+ r = pygame.Rect(self.position - pygame.Vector2(self.horizontal_padding, self.vertical_padding) - self.centering,
+ pygame.Vector2(self.width + 2 * self.horizontal_padding, self.height + self.vertical_padding))
+ pygame.draw.rect(surface, self.fill_colour, r)
+
+
+pygame.init()
+
+SCREEN_HEIGHT = 820
+SCREEN_WIDTH = 1260
+screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
+pygame.display.set_caption("Cookie Clicker")
+icon = pygame.transform.scale(Cookie.cookie_image, (32, 32))
+pygame.display.set_icon(icon)
+cookie = Cookie(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2)
+score = 0
+score_multiplier = 1
+multiplier_cost = 10
+score_base = 1
+base_cost = 1
+autoclicker = 0
+autoclicker_cost = 100
+autoclicker_delay_MS = 1000
+autoclick_event = pygame.USEREVENT
+pygame.time.set_timer(autoclick_event, autoclicker_delay_MS)
+
+score_label_text = [f"Cookies:: {score}"]
+score_label = Label(Label.horizontal_padding, 0, score_label_text, 24, text_colour=(0, 0, 0))
+
+cookies_per_click = 1
+cookies_per_click_label_text = [f"{cookies_per_click} cookies per click"]
+cookies_per_click_label = Label(Label.horizontal_padding, score_label.height + Label.vertical_padding,
+ cookies_per_click_label_text, 17, text_colour=(95, 96, 102))
+cookies_per_second = 0
+cookies_per_second_label_text = [f"{cookies_per_second} cookies per second"]
+cookies_per_second_label = Label(Label.horizontal_padding,
+ score_label.height + cookies_per_click_label.height + Label.vertical_padding * 2,
+ cookies_per_second_label_text, 17, text_colour=(95, 96, 102))
+
+title_label_text = ["Cookie Clicker"]
+title_label = Label(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2 - Cookie.radius - Label.vertical_padding * 2 - 50,
+ title_label_text, 50)
+
+subtitle_label_text = ["–BETTER EDITION–"]
+subtitle_label = Label(SCREEN_WIDTH / 2,
+ SCREEN_HEIGHT / 2 - Cookie.radius - Label.vertical_padding * 2 - 50 + title_label.height / 2,
+ subtitle_label_text, 20, text_colour=(74, 76, 82))
+
+base_cost_button_text = [f"Base Cookies Per Click: {score_base}", f"Cost to upgrade: {base_cost}"]
+base_cost_button = Button(Label.horizontal_padding * 2, SCREEN_HEIGHT / 2, base_cost_button_text, 16,
+ fill_color=(94, 131, 214), text_colour=(10, 10, 10), outline_colour=(50, 50, 50))
+
+multiplier_cost_button_text = [f"Cookie Multiplier: {score_multiplier}", f"Cost to upgrade: {multiplier_cost}"]
+multiplier_cost_button = Button(Label.horizontal_padding * 2,
+ SCREEN_HEIGHT / 2 + base_cost_button.height + Label.vertical_padding * 2 + Label.outline_thickness * 2,
+ multiplier_cost_button_text, 16, fill_color=(94, 131, 214), text_colour=(10, 10, 10),
+ outline_colour=(50, 50, 50))
+
+autoclicker_cost_button_text = [f"Autoclickers: {autoclicker}", f"Cost to upgrade: {autoclicker_cost}"]
+autoclicker_cost_button = Button(Label.horizontal_padding * 2,
+ SCREEN_HEIGHT / 2 + base_cost_button.height + multiplier_cost_button.height + Label.vertical_padding * 4 + Label.outline_thickness * 4,
+ autoclicker_cost_button_text, 16, fill_color=(94, 131, 214), text_colour=(10, 10, 10),
+ outline_colour=(50, 50, 50))
+
+shop_title_label_text = ["Shop"]
+shop_title_label = Label(Label.horizontal_padding * 2,
+ SCREEN_HEIGHT / 2 - base_cost_button.height / 2 - Label.vertical_padding * 4 - Label.outline_thickness * 4,
+ shop_title_label_text, 25, text_colour=(44, 46, 52))
+shop_items = [base_cost_button.width, multiplier_cost_button.width, autoclicker_cost_button.width, score_label.width,
+ cookies_per_click_label.width, cookies_per_second_label.width, 250]
+shop_limit = max(shop_items) + 2 * Label.horizontal_padding
+shop = Rectangle(0, 0, shop_limit, SCREEN_HEIGHT, (150, 179, 242))
+
+total_shop_height = (
+ SCREEN_HEIGHT / 2 + base_cost_button.height + multiplier_cost_button.height + Label.vertical_padding * 4 + Label.outline_thickness * 4 + (
+ autoclicker_cost_button.height / 2 + Label.vertical_padding + Label.outline_thickness)) - (
+ SCREEN_HEIGHT / 2 - base_cost_button.height / 2 - Label.vertical_padding * 4 - Label.outline_thickness * 4 - shop_title_label.height / 2 - Label.vertical_padding - Label.outline_thickness)
+shop_y_offset = total_shop_height / 2 - 32.5 # too lazy to find the right way to do this
+base_cost_button.update(0, y=base_cost_button.position.y - shop_y_offset + base_cost_button.height / 2)
+multiplier_cost_button.update(0,
+ y=multiplier_cost_button.position.y - shop_y_offset + multiplier_cost_button.height / 2)
+autoclicker_cost_button.update(0,
+ y=autoclicker_cost_button.position.y - shop_y_offset + autoclicker_cost_button.height / 2)
+shop_title_label.update(0, y=shop_title_label.position.y - shop_y_offset + shop_title_label.height / 2)
+
+num_falling_cookies = 15
+falling_cookies = [FallingCookie() for i in range(num_falling_cookies)]
+falling_cookie_multiplier = 2
+
+click_effects = []
+
+C = CPSCounter()
+
+fps_cap = 60
+fps_display_iteration = 0
+fps_display_refresh_rate = 60 # every this number frames it refreshes
+fps = fps_cap
+
+clock = pygame.time.Clock()
+delta = 1
+background_colour = (134, 161, 219)
+
+fps_label_text = [f"FPS: {fps}"]
+fps_label = Label(0, Label.vertical_padding, fps_label_text, 24, text_colour=(0, 0, 0))
+
+is_running = True
+while is_running:
+
+ screen.fill(background_colour)
+
+ for event in pygame.event.get():
+ if event.type == pygame.QUIT:
+ is_running = False
+ elif event.type == pygame.MOUSEBUTTONUP and event.button == 1:
+ if cookie.is_touching_mouse_pointer():
+ score += score_base * score_multiplier
+ C.add_click()
+ click_effects.append(
+ Label(pygame.mouse.get_pos()[0], pygame.mouse.get_pos()[1], [f"+{score_base * score_multiplier}"],
+ 17, text_colour=(10, 10, 10)))
+ for c in falling_cookies:
+ if c.is_touching_mouse_pointer():
+ c.position = c.reset()
+ score += score_base * score_multiplier * falling_cookie_multiplier
+ C.add_click()
+ click_effects.append(Label(pygame.mouse.get_pos()[0], pygame.mouse.get_pos()[1],
+ [f"+{score_base * score_multiplier * falling_cookie_multiplier}"], 20,
+ text_colour=(10, 10, 10)))
+
+ if base_cost_button.is_touching_mouse_pointer() and score >= base_cost:
+ click_effects.append(Label(pygame.mouse.get_pos()[0], pygame.mouse.get_pos()[1],
+ [f"-{base_cost}"], 20, text_colour=(70, 70, 70)))
+ base_cost = base_cost_button.run_function(increase_score_base)
+ elif multiplier_cost_button.is_touching_mouse_pointer() and score >= multiplier_cost:
+ click_effects.append(Label(pygame.mouse.get_pos()[0], pygame.mouse.get_pos()[1],
+ [f"-{base_cost}"], 20, text_colour=(70, 70, 70)))
+ multiplier_cost = multiplier_cost_button.run_function(increase_score_multiplier)
+ elif autoclicker_cost_button.is_touching_mouse_pointer() and score >= autoclicker_cost:
+ click_effects.append(Label(pygame.mouse.get_pos()[0], pygame.mouse.get_pos()[1],
+ [f"-{base_cost}"], 20, text_colour=(70, 70, 70)))
+ autoclicker_cost = autoclicker_cost_button.run_function(increase_autoclicker)
+ elif event.type == autoclick_event:
+ score += score_base * score_multiplier * autoclicker
+ if autoclicker > 0:
+ click_effects.append(Label(pygame.mouse.get_pos()[0], pygame.mouse.get_pos()[1],
+ [f"+{score_base * score_multiplier * autoclicker}"], 25,
+ text_colour=(25, 25, 25)))
+ fps_display_iteration += 1
+ if fps_display_iteration % fps_display_refresh_rate == 0:
+ fps = min(1000 // delta, fps_cap)
+
+ fps_display_iteration %= fps_display_refresh_rate
+ fps_label_text = [f"FPS: {format_number(fps)}"]
+ fps_label.update(delta, fps_label_text, x=SCREEN_WIDTH - (Label.horizontal_padding * 2 + fps_label.width))
+ fps_label.draw(screen, centered_x=False, centered_y=False)
+
+ shop_items = [base_cost_button.width, multiplier_cost_button.width, autoclicker_cost_button.width,
+ score_label.width, cookies_per_click_label.width, cookies_per_second_label.width, 250]
+ shop_limit = max(shop_items) + 2 * Label.horizontal_padding
+ shop.update(width=shop_limit)
+ shop.draw(screen, centered_x=False, centered_y=False)
+
+ score_label_text = [f"Cookies: {format_number(score)}"]
+ score_label.update(delta, score_label_text)
+ score_label.draw(screen, centered_x=False, centered_y=False)
+
+ cookies_per_click = score_base * score_multiplier
+ if cookies_per_click != 1:
+ cookies_per_click_label_text = [f"{format_number(cookies_per_click)} cookies per click"]
+ else:
+ cookies_per_click_label_text = [f"{format_number(cookies_per_click)} cookie per click"]
+ cookies_per_click_label.update(delta, cookies_per_click_label_text)
+ cookies_per_click_label.draw(screen, centered_x=False, centered_y=False)
+
+ cookies_per_second = (C.cps + autoclicker) * cookies_per_click
+ if cookies_per_second != 1:
+ cookies_per_second_label_text = [f"{format_number(cookies_per_second)} cookies per second"]
+ else:
+ cookies_per_second_label_text = [f"{format_number(cookies_per_second)} cookie per second"]
+ cookies_per_second_label.update(delta, cookies_per_second_label_text)
+ cookies_per_second_label.draw(screen, centered_x=False, centered_y=False)
+
+ title_label.draw(screen)
+ subtitle_label.draw(screen)
+
+ shop_title_label.update(delta, x=shop_limit / 2 - shop_title_label.width / 2 - Label.horizontal_padding)
+ shop_title_label.draw(screen, centered_x=False, centered_y=True)
+
+ base_cost_button_text = [f"Base Cookies Per Click: {format_number(score_base)}",
+ f"Cost to upgrade: {format_number(base_cost)}"]
+ base_cost_button.update(delta, new_text=base_cost_button_text)
+ base_cost_button.draw(screen, centered_x=False, centered_y=True, outlined=True, filled=True)
+
+ multiplier_cost_button_text = [f"Cookie Multiplier: {format_number(score_multiplier)}",
+ f"Cost to upgrade: {format_number(multiplier_cost)}"]
+ multiplier_cost_button.update(delta, new_text=multiplier_cost_button_text)
+ multiplier_cost_button.draw(screen, centered_x=False, centered_y=True, outlined=True, filled=True)
+
+ autoclicker_cost_button_text = [f"Autoclickers: {format_number(autoclicker)}",
+ f"Cost to upgrade: {format_number(autoclicker_cost)}"]
+ autoclicker_cost_button.update(delta, new_text=autoclicker_cost_button_text)
+ autoclicker_cost_button.draw(screen, centered_x=False, centered_y=True, outlined=True, filled=True)
+
+ C.update(delta)
+ C.draw(screen)
+
+ cookie.update(delta, 0)
+ cookie.draw(screen)
+ for c in falling_cookies:
+ c.update(delta, shop_limit)
+ c.draw(screen)
+
+ effect_del_offset = 0
+ for i, effect in enumerate(click_effects):
+ effect.update(delta, y=effect.position.y - FallingCookie.gravity)
+ effect.draw(screen)
+ if effect.position.y + effect.height < 0:
+ del click_effects[i - effect_del_offset]
+ effect_del_offset += 1
+
+ pygame.display.update()
+ delta = clock.tick(fps_cap)
+
+pygame.quit()
projects / Cookie-Clicker.git / commitdiff
