ennucore
/
mipt_labs
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

lab4

master
Lev 3 years ago
parent
4f4c0dfcaa
commit
657ef7dbd8
2 changed files with 130 additions and 14 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. BIN
      lab4/IntroRust.otf
  2. 140
      lab4/main.py

BIN
lab4/IntroRust.otf
View File

Binary file not shown.

140
lab4/main.py
Unescape View File

@ -5,6 +5,8 @@ from dataclasses import dataclass, field
import time
import numpy as np
import typing
import json
import os
from random import uniform, choice
if typing.TYPE_CHECKING:
from nptyping import NDArray
@ -22,10 +24,21 @@ dt = 10
# load the font
font = pygame.font.Font('orbitron-medium.otf', 15)
font_large = pygame.font.Font('orbitron-medium.otf', 25)
font_even_larger = pygame.font.Font('orbitron-medium.otf', 40)
# Orbitron doesn't support unicode, so I have to get another font for the scoreboard
unicode_font_large = pygame.font.Font('IntroRust.otf', 25)
N_BALLS = 18
ENDGAME_BUTTON_RECT = (850, 15, 20, 20)
BGCOLOR = (40, 46, 70)
# List of ball types: [(radius, speed, color, points)]
BALL_TYPES = [(25, 0.035, (185, 20, 50), 10), (18, 0.055, (220, 0, 0), 30), (20, 0.05, (60, 0, 160), 20)]
# List of ball types: [(radius, speed, color, points, shape, deviation_radius)]
BALL_TYPES = [
(25, 0.035, (185, 20, 50), 10, 'circle', 0),
(20, 0.05, (60, 0, 160), 20, 'circle', 0),
(18, 0.055, (220, 0, 0), 30, 'circle', 0),
(30, 0.055, (220, 0, 0), 40, 'triangle', 30),
]
@dataclass
@ -36,10 +49,19 @@ class Game:
:param score: user's score
:param balls: the list of balls
:param target_ball_number: the target number of balls on screen at a given time
:param game_end_time: the timeout of the game
:param game_ended: true if the game has ended
:param user_name: user's name for the scoreboard
"""
score: int = 0
balls: typing.List[Ball] = field(default_factory=lambda: [Ball.new_random() for _ in range(N_BALLS)])
target_ball_number: int = N_BALLS
game_end_time: float = field(default_factory=lambda: time.time() + 30)
game_ended: bool = False
scoreboard: typing.List[typing.Tuple[str, int]] = field(default_factory=lambda: list()
if not os.path.exists('scoreboard.json')
else json.load(open('scoreboard.json')))
user_name: str = ''
def draw_everything(self, screen: pygame.Surface):
"""
@ -48,35 +70,101 @@ class Game:
"""
for ball in self.balls:
ball.draw_the_ball(screen)
if not self.game_ended:
pygame.draw.rect(screen, (255, 255, 255), pygame.Rect(0, 0, W, OFFSET))
text_surface = font_large.render(f'Score: {self.score}', False, (0, 0, 0))
text_surface = font_large.render(f'Score: {self.score}', True, (0, 0, 0))
screen.blit(text_surface, (360, 15))
time_left = self.game_end_time - time.time()
time_text_surface = font_large.render(
f'{int(time_left / 60)}:{int(time_left % 60):02}', False,
(0, 0, 0) if time_left > 10 else (220, 0, 0))
screen.blit(time_text_surface, (760, 15))
# draw the button to end game (which is a red rect)
pygame.draw.rect(screen, (255, 0, 0), ENDGAME_BUTTON_RECT)
else:
screen.fill((*BGCOLOR, 150), None, pygame.BLEND_RGBA_MULT)
game_over_text = font_even_larger.render(f'Game over', True, (255, 0, 0))
score_text = font_even_larger.render(f'Score: {self.score}', True, (255, 255, 255))
screen.blit(game_over_text, (W / 2 - game_over_text.get_width() / 2,
-180 + H / 2 - game_over_text.get_height() / 2))
screen.blit(score_text, (W / 2 - score_text.get_width() / 2, -120 + H / 2 - score_text.get_height() / 2))
y = H / 2
if len(self.scoreboard):
scoreboard_title = font_large.render('Scoreboard:', False, (255, 255, 255))
screen.blit(scoreboard_title, (W / 2 - scoreboard_title.get_width() / 2,
-40 + H / 2 - scoreboard_title.get_height() / 2))
y = -30 + H / 2 + scoreboard_title.get_height() / 2
# Zip with a range of 5 instead of enumerating so that we show only the first 5 records
for i, record in zip(range(5), sorted(self.scoreboard, key=lambda record: -record[1])):
text = unicode_font_large.render(f'{i + 1}. {record[0]} - {record[1]}', True, (255, 255, 255))
y += 10 + text.get_height()
screen.blit(text, (200, y))
username_prompt = font_large.render('Your name:', False, (255, 255, 255))
screen.blit(username_prompt, (200, y + 100))
username_current = unicode_font_large.render(self.user_name, False, (255, 255, 255))
pygame.draw.rect(
screen,
[int(v * 0.5 + 255 * 0.5) for v in BGCOLOR],
(200 + username_prompt.get_width() + 30, y + 80, max(400, username_current.get_width() + 20),
username_current.get_height() + 20))
screen.blit(username_current, (200 + username_prompt.get_width() + 40, y + 90))
def process_click(self, x: float, y: float):
"""
Process mouse click, check if the user clicked on a ball and process it
Process mouse click, check if the user clicked on a ball or the endgame button and process it
:param x: click's x coordinate
:param y: click's y coordinate
"""
e_x = ENDGAME_BUTTON_RECT[0] <= x <= ENDGAME_BUTTON_RECT[0] + ENDGAME_BUTTON_RECT[2]
e_y = ENDGAME_BUTTON_RECT[1] <= y <= ENDGAME_BUTTON_RECT[1] + ENDGAME_BUTTON_RECT[3]
if e_x and e_y:
self.game_ended = True
self.user_name = ''
return
if self.game_ended:
return
for i in range(len(self.balls)):
if self.balls[i].is_point_inside(x, y - OFFSET):
self.score += self.balls[i].points
self.balls.pop(i)
break
def process_keypress(self, event):
"""
Process keypress for name input
:param event: the keypress event
"""
if event.key == pygame.K_BACKSPACE:
self.user_name = self.user_name[:-1]
else:
self.user_name += event.unicode
self.write_scoreboard()
def tick(self, dt: float):
"""
Progress for some time
dt: time period, ms
"""
if time.time() > self.game_end_time and not self.game_ended:
self.game_ended = True
self.user_name = ''
if len(self.balls) < self.target_ball_number:
n_balls = round((self.target_ball_number - len(self.balls))) # * (1 - 0.9 ** dt))
self.balls.extend([Ball.new_random() for _ in range(n_balls)])
for ball in self.balls:
ball.tick(dt)
def write_scoreboard(self):
"""
Save scoreboard (`self.scoreboard`) to scoreboard.json as JSON with the new record
"""
if not self.user_name:
return
with open('scoreboard.json', 'w') as f:
f.write(json.dumps(sorted(self.scoreboard + [(self.user_name, self.score)], key=lambda record: -record[1])))
@dataclass
class Ball:
@ -90,6 +178,9 @@ class Ball:
very sad and depressing
:param radius: the radius of the ball on screen in pixels
:param color: ball's color
:param shape: shape of the ball (circle, triangle)
:param deviation_radius: if the radius is >0, the ball will be rotating arond its actual trajectory
:param deviation_angle: the phase of the ball's rotation
"""
points: int = 10
position: NDArray[(2,), float] = field(default_factory=lambda: np.array([uniform(0, W), uniform(0, H)]))
@ -97,32 +188,54 @@ class Ball:
time_of_death: float = field(default_factory=lambda: time.time() + DEFAULT_TTL)
radius: float = DEFAULT_RADIUS
color: typing.Tuple[int, int, int] = (255, 0, 0)
shape: str = 'circle'
deviation_radius: float = 0
deviation_angle: float = 0
@classmethod
def new_random(cls) -> Ball:
radius, speed, color, points = choice(BALL_TYPES)
radius, speed, color, points, shape, deviation_radius = choice(BALL_TYPES)
angle = uniform(0, np.pi)
return cls(points, radius=radius, color=color, velocity=speed * np.array([np.sin(angle), np.cos(angle)]))
return cls(points, radius=radius, color=color, velocity=speed * np.array([np.sin(angle), np.cos(angle)]),
shape=shape, deviation_radius=deviation_radius)
def draw_the_ball(self, screen: pygame.Surface):
"""
Just draw the ball on the screen
:param screen: the screen, obviously
"""
pygame.draw.circle(screen, self.color, [self.position[0], self.position[1] + OFFSET], self.radius)
x, y = self.position_with_shift()[0], self.position_with_shift()[1] + OFFSET
if self.shape == 'triangle':
angles = [0, np.pi * 2 / 3, np.pi * 4 / 3]
pygame.draw.polygon(screen, self.color, [
(
x + self.radius * np.sin(angle + self.deviation_angle),
y + self.radius * np.cos(angle + self.deviation_angle)
) for angle in angles])
else:
pygame.draw.circle(screen, self.color, [x, y], self.radius)
text_surface = font.render(str(self.points), False, (0, 0, 0))
screen.blit(text_surface, (
round(self.position[0] - text_surface.get_rect().width / 2),
round(self.position[1] - text_surface.get_rect().height / 2) + OFFSET
round(x - text_surface.get_rect().width / 2),
round(y - text_surface.get_rect().height / 2)
))
def position_with_shift(self) -> typing.Tuple[float, float]:
"""
Get position including deviation (rotation arond the true center)
"""
return (
self.position[0] + self.deviation_radius * np.cos(self.deviation_angle),
self.position[1] + self.deviation_radius * np.sin(self.deviation_angle)
)
def is_point_inside(self, x: float, y: float) -> bool:
"""
Check if a given point is inside this circle (to handle click events)
Check if a given point is inside this ball (to handle click events)
:param x: point's x coordinate
:param y: point's y coordinate
"""
return (self.position[0] - x) ** 2 + (self.position[1] - y) ** 2 <= self.radius ** 2
return (self.position_with_shift()[0] - x) ** 2 + (self.position_with_shift()[1] - y) ** 2 <= self.radius ** 2
def tick(self, dt: float):
"""
@ -142,6 +255,7 @@ class Ball:
if self.position[1] >= H - self.radius:
self.position[1] = H - self.radius
self.velocity[1] *= -1
self.deviation_angle += dt * 2 * np.pi / 2000
# create the display surface object
@ -165,9 +279,11 @@ while True:
sys.exit(0)
if event.type == pygame.MOUSEBUTTONUP:
game.process_click(*pygame.mouse.get_pos())
if event.type == pygame.KEYDOWN:
game.process_keypress(event)
# clear the screen
screen.fill((40, 46, 70))
screen.fill(BGCOLOR)
game.tick(dt)
game.draw_everything(screen)

Write Preview
Loading…
Cancel
Save