v1 release

Author: HalfLeif

.gitignore

@@ -0,0 +1,2 @@
+*.swp
+*__pycache__

README.md

@@ -0,0 +1,6 @@
+# Starting-Programming
+
+Leif was here
+me too!
+Let`s make a conflict
+

core/display_high_score.py

@@ -0,0 +1,99 @@
+import pygame
+from enum import Enum
+
+from core import score
+
+
+white = (255, 255, 255)
+green = (0, 255, 0)
+blue = (0, 0, 128)
+
+
+class Alignment(Enum):
+  CENTER = 0
+  RIGHT = 1
+
+class TextArea:
+  '''Draws a bounding box around several text rects.'''
+
+  def __init__(self, screen, y):
+    self.screen = screen
+    self.screen_size = screen.get_size()
+    self.rects = []
+    self.y = y
+
+
+  def add_text(self, text_string, fsize, align=Alignment.CENTER, offset=0):
+    font = pygame.font.Font('freesansbold.ttf', fsize)
+    text = font.render(text_string, True, white, blue)
+
+    self.y += 0.5*fsize
+    textRect = text.get_rect()
+    if align == Alignment.CENTER:
+      textRect.center = (self.screen_size[0] // 2, self.y)
+    elif align == Alignment.RIGHT:
+      textRect.top = self.y
+      textRect.right = offset
+    else:
+      raise ValueError(f'Alignment not implemented: {align}')
+
+    self.y += 0.5*fsize + 5
+    self.rects.append((text, textRect))
+    return textRect
+
+
+  def add_row(self, fields, fsize, offset=0):
+    '''Aligns each column on RIGHT.'''
+    y = self.y
+    # middle = self.screen_size[0] // 2
+    right = offset
+    # Referencing other rects for distancing easily produces bad results, since
+    # prevous rect size differs depending on its content. For now hardcode
+    # difference. A proper solution would be to make a grid layout or so.
+    for f in reversed(fields):
+      self.y = y
+      rect = self.add_text(str(f), fsize, align=Alignment.RIGHT, offset=right)
+      right -= 140
+
+    return rect
+
+
+  def bounding_box(self):
+    universe = self.rects[0][1]
+    for (text, rec) in self.rects[1:]:
+      universe = universe.union(rec)
+    return universe.inflate(50, 50)
+
+
+  def draw(self):
+    box = self.bounding_box()
+    pygame.draw.rect(self.screen, blue, box)
+    pygame.draw.rect(self.screen, white, box, width=2)
+    for (text, textRect) in self.rects:
+      self.screen.blit(text, textRect)
+    pygame.display.update()
+
+
+def high_score_screen(screen, score, resources):
+  pygame.mixer.music.load(resources.sad_music)
+  pygame.mixer.music.play()
+
+  area = TextArea(screen, 200)
+
+  title = area.add_text('HighScore', 64)
+  area.add_text('', 16)
+
+  offset = title.right + 30
+  area.add_row(('Name', 'Level', 'Score'), 24, offset=offset)
+  high_score = score.get_unique_scores()
+  for row in high_score[:10]:
+    area.add_row(row, 24, offset=offset)
+
+  area.add_text('', 16)
+  area.add_row(score.last, 32, offset=offset)
+  area.draw()
+
+  y = 100 + area.bounding_box().bottom
+  bottom = TextArea(screen, y)
+  bottom.add_text('Press ESC to quit. Press ENTER to try again.', 24)
+  bottom.draw()

core/game.py

@@ -0,0 +1,75 @@
+import pygame
+import time
+
+from core import level
+
+class Game:
+  '''Runs one game instance.
+
+     Sums player score.
+  '''
+  def __init__(self, screen, resources):
+    self.screen = screen
+    self.resources = resources
+    self.score = 0
+    self.highest_level = 0
+    self.cheat = False
+
+
+  def run(self):
+    alive = True
+    num_level = 0
+    while alive:
+      num_level += 1
+      alive = self.run_level(num_level)
+    self.highest_level = num_level
+
+
+  def play_music(self, num_level):
+    change_each = 5
+    if (num_level % 5 != 1):
+      # continue with previous music without changing
+      return
+    track = (num_level // 5) % len(self.resources.music)
+    # pygame.mixer.music.stop()
+    pygame.mixer.music.load(self.resources.music[track])
+    pygame.mixer.music.play()
+
+
+  def run_level(self, num_level):
+    '''Runs one level of the game.
+
+       Returns whether the player cleared the level.
+       Difficulty increases with `num_level`.
+    '''
+    instance = level.Level(num_level, self.screen, self.resources)
+    self.play_music(num_level)
+
+    running = True
+    while running:
+      # 50 fps = 1/50 sec = 20 ms
+      # Sleep for 20 ms
+      time.sleep(0.020)
+      if instance.won or instance.lost:
+        running = False
+
+      instance.tick()
+      instance.draw()
+
+      for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+          running = False
+        if event.type == pygame.KEYUP:
+          if event.key == pygame.K_9:
+            print('You cheated!')
+            instance.won = True
+            self.cheat = True
+          instance.reset_direction(event.key)
+        if event.type == pygame.KEYDOWN:
+          if event.key == pygame.K_ESCAPE:
+            running = False
+          instance.add_direction(event.key)
+
+    self.score += instance.compute_score()
+    time.sleep(1)
+    return instance.won

core/level.py

@@ -0,0 +1,172 @@
+import math
+import random
+import pygame
+
+from core import update
+
+BACKGROUND=(40, 110, 150)
+VICTORY_BG=(0xff, 0xd3, 0x00)
+DEFEAT_BG=(106, 40, 126)
+
+START_ALPHAS=7
+GOAL_RADIUS=50
+ALPHA_RADIUS=update.ALPHA_RADIUS # TODO refactor
+MAX_SPEED=10
+
+
+def direction(key, speed=MAX_SPEED):
+  if key == pygame.K_DOWN:
+    return (0,speed)
+  if key == pygame.K_UP:
+    return (0,0-speed)
+  if key == pygame.K_RIGHT:
+    return (speed,0)
+  if key == pygame.K_LEFT:
+    return (0-speed,0)
+  return (0,0)
+
+
+def reset_velocity(velocity, key):
+  vx, vy = velocity
+  if key in [pygame.K_DOWN, pygame.K_UP]:
+    vy = 0
+  if key in [pygame.K_LEFT, pygame.K_RIGHT]:
+    vx = 0
+  return (vx, vy)
+
+
+def get_background(num):
+  min = [30, 100, 160]
+  max = [85, 240, 255]
+  def update_color(i, c):
+    return random.randrange(min[i], max[i])
+  return [update_color(i,c) for (i,c) in enumerate(BACKGROUND)]
+
+
+def generate_position(screen_size):
+  max_x, max_y = screen_size
+  x = random.uniform(0, max_x)
+  y = random.uniform(0, max_y)
+  return (x,y)
+
+
+def generate_position_with_distance(player, image_size, distance, screen_size):
+  pos = generate_position(screen_size)
+  while update.touches_circle(player, image_size, pos, distance):
+    pos = generate_position(screen_size)
+  return pos
+
+
+def generate_alphas(player, number, image_size, screen_size):
+  alphas = []
+  alpha_velocities = []
+  for i in range(number):
+    alphas.append(generate_position_with_distance(player, image_size, 200, screen_size))
+    alpha_velocities.append((0,0))
+  return alphas, alpha_velocities
+
+
+class Level:
+
+  def __init__(self, num_level, screen, resources):
+    self.num_level = num_level
+    self.screen = screen
+    self.resources = resources
+    self.survived_iterations = 0
+
+    self.screen_size = self.screen.get_size()
+    self.image_size = self.resources.player_img.get_rect().size
+
+    self.won = False
+    self.lost = False
+
+    self.player = (0,0)
+    self.velocity = (0,0)
+
+    self.goal = generate_position_with_distance(self.player, self.image_size, 350, self.screen_size)
+    num_deltas = 0
+    if num_level >= 3:
+      num_deltas = num_level - 2
+    num_alphas = START_ALPHAS + 3 * (self.num_level - 1) - 2*num_deltas
+    self.alphas, self.alpha_velocities = generate_alphas(self.player, num_alphas, self.image_size, self.screen_size)
+    self.background = get_background(self.num_level)
+
+    self.delta_alphas, self.delta_velocities = generate_alphas(self.player, num_deltas, self.image_size, self.screen_size)
+
+
+  def draw_img(self, img, center_pos):
+    w = img.get_width()
+    h = img.get_height()
+    (x,y) = center_pos
+    self.screen.blit(img, (x - w/2, y - h/2))
+
+
+  def draw(self):
+    '''Draws the current state.'''
+    if self.won:
+      background = VICTORY_BG
+    elif self.lost:
+      background = DEFEAT_BG
+    else:
+      background = self.background
+
+    self.screen.fill(background)
+    self.draw_img(self.resources.goal_img, self.goal)
+
+    self.draw_img(self.resources.player_img, self.player)
+    for alpha in self.alphas:
+      self.draw_img(self.resources.alpha_img, alpha)
+
+    for delta in self.delta_alphas:
+      self.draw_img(self.resources.delta_img, delta)
+
+    pygame.display.flip()
+
+
+  def tick(self):
+    '''Updates the model one iteration.
+
+       If already won or lost, changes nothing.
+    '''
+    if self.won or self.lost:
+      return
+
+    self.survived_iterations += 1
+    self.player = update.add(self.player, self.velocity)
+    self.player = update.bounds(self.player, self.image_size, self.screen_size)
+    self.alphas, self.alpha_velocities = update.move_alphas(self.alphas, self.alpha_velocities, self.screen_size)
+
+    self.delta_alphas, self.delta_velocities = update.move_deltas(self.delta_alphas, self.delta_velocities, self.screen_size, self.player)
+
+    if update.touches_circle(self.player, self.image_size, self.goal, GOAL_RADIUS):
+      pygame.mixer.Sound.play(self.resources.door_sound)
+      self.won = True
+
+    for alpha in (self.alphas + self.delta_alphas):
+      if not self.won and update.touches_circle(self.player, self.image_size, alpha, ALPHA_RADIUS):
+        pygame.mixer.music.stop()
+        pygame.mixer.Sound.play(self.resources.explosion_sound)
+        self.lost = True
+        break
+
+
+  def compute_score(self):
+    '''If won, returns max score.
+
+       Otherwise return asymptotically approaching max score based on survived_iterations.
+    '''
+    max_score = self.num_level * 1000
+    if self.won: return max_score
+
+    k = 1e-3
+    progression = 1 - math.exp(-k*self.survived_iterations)
+    return math.floor(max_score * progression)
+
+
+  def reset_direction(self, key):
+    self.velocity = reset_velocity(self.velocity, key)
+
+
+  def add_direction(self, key):
+    d = direction(key)
+    self.velocity = update.add(self.velocity, d)