Style redesign to match telearn.best aesthetic, URL ID hashing, and share link generator

projects/DEMO/Student1/MakeCode 跳舞機/link.txt

@@ -0,0 +1 @@
+https://makecode.com/_fcva84c8D5jD

projects/DEMO/Student1/Pygame_Breakout/main.py

@@ -0,0 +1,257 @@
+import pygame
+import random
+
+SCREEN_WIDTH = 800
+SCREEN_HEIGHT = 600
+
+BLACK = (0, 0, 0)
+WHITE = (255, 255, 255)
+YELLOW = (255, 255, 0)
+RED = (255, 0, 0)
+
+PADDLE_NEW_WIDTH = 110
+PADDLE_NEW_HEIGHT = 22
+BRICK_NEW_WIDTH = 80
+BRICK_NEW_HEIGHT = 25
+
+BALL_RADIUS = 10
+
+def draw_text(surface, text, size, x, y):
+    font = pygame.font.Font(None, size)
+    text_surface = font.render(text, True, WHITE)
+    text_rect = text_surface.get_rect()
+    text_rect.midtop = (x, y)
+    surface.blit(text_surface, text_rect)
+
+class Paddle(pygame.sprite.Sprite):
+    def __init__(self):
+        super().__init__()
+
+        self.animation_frames = [
+            pygame.transform.scale( pygame.image.load("assets/paddle_1.png").convert_alpha(), (PADDLE_NEW_WIDTH, PADDLE_NEW_HEIGHT) ),
+            pygame.transform.scale( pygame.image.load("assets/paddle_2.png").convert_alpha(), (PADDLE_NEW_WIDTH, PADDLE_NEW_HEIGHT) ),
+            pygame.transform.scale( pygame.image.load("assets/paddle_3.png").convert_alpha(), (PADDLE_NEW_WIDTH, PADDLE_NEW_HEIGHT) )
+        ]
+        self.current_frame = 0
+        self.image = self.animation_frames[self.current_frame]
+
+        self.rect = self.image.get_rect()
+        self.rect.x = (SCREEN_WIDTH - self.rect.width) // 2
+        self.rect.y = SCREEN_HEIGHT - self.rect.height - 10
+
+        self.last_update = pygame.time.get_ticks()
+        self.frame_rate = 100
+
+    def update(self):
+        now = pygame.time.get_ticks()
+        if now - self.last_update > self.frame_rate:
+            self.last_update = now
+            self.current_frame = (self.current_frame + 1) % len(self.animation_frames)
+            self.image = self.animation_frames[self.current_frame]
+
+    def move(self,keys):
+        if keys[pygame.K_LEFT]:
+            self.rect.x -= 7
+        if keys[pygame.K_RIGHT]:
+            self.rect.x += 7
+        if keys[pygame.K_UP]:
+            self.rect.y -= 7
+        if keys[pygame.K_DOWN]:
+            self.rect.y += 7
+        if self.rect.right >= SCREEN_WIDTH:
+            self.rect.right = SCREEN_WIDTH
+        if self.rect.left <= 0:
+            self.rect.left = 0
+    def widden(self):
+        print("球拍變寬了")
+        center = self.rect.x
+        new_width = int(PADDLE_NEW_WIDTH*1.5)
+        self.animation_frames = [
+            pygame.transform.scale(frame, (new_width, PADDLE_NEW_HEIGHT))
+            for frame in self.animation_frames
+        ]
+
+        
+class Ball(pygame.sprite.Sprite):
+    def __init__(self):
+        super().__init__()
+        self.image = pygame.image.load("assets/ball_blue.png").convert_alpha()
+        self.image = pygame.transform.scale(self.image, (BALL_RADIUS * 2, BALL_RADIUS * 2))
+        self.rect = self.image.get_rect()
+        self.reset()
+
+    def reset(self):
+        self.rect.x = SCREEN_WIDTH // 2
+        self.rect.y = SCREEN_HEIGHT // 2 + 100
+        self.speed_x = random.choice([4, -4])
+        self.speed_y = -4
+
+    def update(self):
+        self.rect.x += self.speed_x
+        self.rect.y += self.speed_y
+        if self.rect.left <= 0 or self.rect.right >= SCREEN_WIDTH:
+           self.speed_x *= -1 
+        
+        if self.rect.top <= 0:
+           self.speed_y *= -1
+        
+class PowerUp(pygame.sprite.Sprite):
+    def __init__(self, x, y, color):
+        super().__init__()
+        self.color = color
+        self.image = pygame.Surface((15,15))
+        self.image.fill(self.color)
+        self.rect = self.image.get_rect()
+        self.rect.centerx = x
+        self.rect.centery = y
+        self.speed_y = 3
+
+    def update(self):
+        self.rect.y += self.speed_y
+        if self.rect.top > SCREEN_HEIGHT:
+            self.kill()
+    
+        
+        
+class Brick(pygame.sprite.Sprite):
+    def __init__(self, x, y, color, points):
+        super().__init__()
+        self.points = points
+        self.color = color
+        self.image_normal = pygame.transform.scale(pygame.image.load(f"assets/brick_{self.color}.png").convert_alpha(), (BRICK_NEW_WIDTH, BRICK_NEW_HEIGHT))
+        self.image_cracked = pygame.transform.scale(pygame.image.load(f"assets/brick_{self.color}_cracked.png").convert_alpha(), (BRICK_NEW_WIDTH, BRICK_NEW_HEIGHT))
+        
+        self.image = self.image_normal
+        self.rect = self.image.get_rect()
+        self.rect.x = x
+        self.rect.y = y
+        self.health = 2
+
+        self.all_sprites_group = None
+        self.powerups_group = None
+        
+    def hit(self):
+        self.health -= 1
+        if self.health <= 0:
+            if random.randint(1,100) <= 20:
+                new_powerup = PowerUp(self.rect.x, self.rect.y, random.choice([YELLOW, RED]))
+                self.all_sprites_group.add(new_powerup)
+                self.powerups_group.add(new_powerup)
+            self.kill()
+            return self.points
+        else:
+            self.image = self.image_cracked
+            return 0
+    
+def game_loop():
+    pygame.init()
+    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
+    pygame.display.set_caption("打磚塊遊戲")
+    clock = pygame.time.Clock()
+    
+    game_state = "start"
+    score = 0
+
+    all_sprites = pygame.sprite.Group()
+    bricks = pygame.sprite.Group()
+    powerups = pygame.sprite.Group()
+    paddle = Paddle()
+    ball = Ball()
+
+    def create_brick_wall():
+        bricks.empty()
+        powerups.empty()
+        all_sprites.empty()
+        all_sprites.add(paddle)
+        all_sprites.add(ball)
+    
+    
+        BRICK_COLORS = ["red", "orange", "yellow", "green", "cyan", "blue", "purple"]
+        for row, color in enumerate(BRICK_COLORS):
+            points = (7 - row) * 10
+            for column in range(SCREEN_WIDTH // (BRICK_NEW_WIDTH + 5)):
+                brick = Brick(
+                    column * (BRICK_NEW_WIDTH + 5) + 10,
+                    row * (BRICK_NEW_HEIGHT + 10) + 50,
+                    color,
+                    points
+                )
+                all_sprites.add(brick)
+                bricks.add(brick)
+
+                brick.all_sprites_group = all_sprites
+                brick.powerups_group = powerups
+
+
+
+    running = True
+    while running:
+        clock.tick(60)
+
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                running = False
+            if event.type == pygame.KEYDOWN:
+                if game_state == "start":
+                    game_state = "playing"
+                    score = 0
+                    paddle.rect.x = (SCREEN_WIDTH - paddle.rect.width) // 2
+                    paddle.rect.y =  SCREEN_HEIGHT - paddle.rect.height - 10
+                    ball.reset()
+                    create_brick_wall()
+                elif game_state == "game_over":
+                    game_state = "start"
+
+        if game_state == "start":
+            screen.fill(BLACK)
+            draw_text(screen, "BREAKOUT", 64, SCREEN_WIDTH / 2, SCREEN_HEIGHT / 4)
+            draw_text(screen, "Press any key to start", 40, SCREEN_WIDTH / 2, SCREEN_HEIGHT * 3 / 4)
+            pygame.display.flip()
+        elif game_state == "playing":
+            keys = pygame.key.get_pressed()
+            paddle.move(keys)
+            all_sprites.update()
+
+            if pygame.sprite.collide_rect(ball, paddle):
+                ball.speed_y *= -1
+            brick_hit_list = pygame.sprite.spritecollide(ball, bricks, False)
+            if brick_hit_list:
+                ball.speed_y *= -1
+                for brick in brick_hit_list:
+                    score += brick.hit()
+            powerups_hit_list = pygame.sprite.spritecollide(paddle, powerups, False)
+            for _ in powerups_hit_list:
+                if _.color == YELLOW:
+                    paddle.widden()
+                    score += 50
+                elif _.color == RED:
+                    ball.speed_y *= 0.3
+                    ball.speed_x *= 3
+                    score += 50
+                _.kill()
+
+
+            if ball.rect.top >= SCREEN_HEIGHT:
+                game_state = "game_over"
+            if not bricks:
+                game_state = "game_over"
+
+
+            screen.fill(BLACK)
+            all_sprites.draw(screen)
+            draw_text(screen, f"Score: {score}", 24, SCREEN_WIDTH / 2, 10)
+            pygame.display.flip()
+            
+        elif game_state == "game_over":
+            screen.fill(BLACK)
+            draw_text(screen, "GAME OVER", 64, SCREEN_WIDTH / 2, SCREEN_HEIGHT / 4)
+            draw_text(screen, f"Final Score: {score}", 50, SCREEN_WIDTH / 2, SCREEN_HEIGHT / 4 - 50)
+            draw_text(screen, "Press any key to restart", 40, SCREEN_WIDTH / 2, SCREEN_HEIGHT * 3 / 4)
+            pygame.display.flip()
+    
+    pygame.quit()
+
+if __name__ == "__main__":
+    game_loop()
+    #|   |
+    #  ˇ

projects/DEMO/Student1/Pygame乒乓/main.py

@@ -0,0 +1,172 @@
+import pygame, sys, random
+
+pygame.init()
+
+SCREEN_WIDTH = 900
+SCREEN_HEIGHT = 600
+BG_COLOR = pygame.Color("#00D000")
+PADDLE_COLOR = pygame.Color("#FF0000")
+PADDLE_WIDTH = 10
+PADDLE_HEIGHT = 100
+BALL_COLOR = pygame.Color(255, 144, 0)
+x = 144
+BALL_SIZE = 15
+LINE_COLOR = pygame.Color("#FFFFFF")
+TEXT_COLOR = pygame.Color("#FFFFFF")
+
+
+title_font = pygame.font.Font(None, 64)
+game_font = pygame.font.Font(None, 48)
+prompt_font = pygame.font.Font(None, 32)
+paddle1 = pygame.Rect(20, SCREEN_HEIGHT // 2 - PADDLE_HEIGHT // 2, PADDLE_WIDTH, PADDLE_HEIGHT)
+paddle2 = pygame.Rect(SCREEN_WIDTH - 20 - PADDLE_WIDTH, SCREEN_HEIGHT // 2 - PADDLE_HEIGHT // 2, PADDLE_WIDTH, PADDLE_HEIGHT)
+ball = pygame.Rect(SCREEN_WIDTH // 2 - BALL_SIZE // 2, SCREEN_HEIGHT // 2 - BALL_SIZE // 2, BALL_SIZE, BALL_SIZE)
+player_1_score = 0
+player_2_score = 0
+
+screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
+pygame.display.set_caption("Pong by Pygame")
+clock = pygame.time.Clock()
+
+ball_moving = False
+running = True
+game_start = False
+game_over = False
+deuce = False
+winner_text = ""
+
+
+while running:
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+        if event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:    
+            if not ball_moving and not game_over:
+                ball_moving = True
+                if not deuce :
+                    if (player_1_score + player_2_score) % 4 == 0 or (player_1_score + player_2_score) % 4 == 1:
+                        ball_speed_x = 7
+                    else:
+                        ball_speed_x = -7
+                else:
+                    if (player_1_score + player_2_score) % 2 == 0:
+                        ball_speed_x = 7
+                    else:
+                        ball_speed_x = -7
+                ball_speed_y = 7*random.choice((1, -1))
+
+            if game_over:
+                game_over = False
+                winner_text = ""
+                player_1_score = 0
+                player_2_score = 0
+                ball_moving = False
+                ball.center = (SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2)
+            if not game_start:
+                game_start = True
+    
+    keys = pygame.key.get_pressed()
+    if keys[pygame.K_w]:
+        paddle1.y -= 10
+    if keys[pygame.K_s]:
+        paddle1.y += 10
+    if keys[pygame.K_UP]:
+        paddle2.y -= 10
+    if keys[pygame.K_DOWN]:
+        paddle2.y += 10
+    screen.fill(BG_COLOR)
+    pygame.draw.rect(screen, PADDLE_COLOR, paddle1)
+    pygame.draw.rect(screen, PADDLE_COLOR, paddle2)
+    pygame.draw.ellipse(screen, BALL_COLOR, ball)
+    pygame.draw.aaline(screen, LINE_COLOR, (SCREEN_WIDTH // 2, 0), (SCREEN_WIDTH // 2, SCREEN_HEIGHT))
+    
+    text1 = game_font.render(f"{player_1_score}", True, TEXT_COLOR)
+    p1_rect = text1.get_rect(topright = (SCREEN_WIDTH // 2 - 60, 20))
+    screen.blit(text1, p1_rect)
+    text2 = game_font.render(f"{player_2_score}", True, TEXT_COLOR)
+    p2_rect = text2.get_rect(topleft = (SCREEN_WIDTH // 2 + 60, 20))
+    screen.blit(text2, p2_rect)
+
+    if not game_start:#開始畫面
+        title_surface = title_font.render("Pong Game", True, TEXT_COLOR)
+        title_rect = title_surface.get_rect(center = (SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2 - 100))
+
+        prompt_surface = prompt_font.render("Press Space to Start", True, TEXT_COLOR)
+        prompt_rect = prompt_rect = prompt_surface.get_rect(center = (SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2))
+
+        screen.blit(title_surface, title_rect)
+        screen.blit(prompt_surface, prompt_rect)
+
+        pong_img = pygame.image.load("pong.png")
+        pong_img = pygame.transform.scale(pong_img, (100, 100))
+        screen.blit(pong_img, (SCREEN_WIDTH // 2 - pong_img.get_width() // 2, SCREEN_HEIGHT//2+40))
+    if not ball_moving and game_start and not game_over:
+        prompt_surface = prompt_font.render("Press Space to Serve", True, TEXT_COLOR)
+        prompt_rect = prompt_surface.get_rect(center = (SCREEN_WIDTH // 2, SCREEN_HEIGHT - 50))
+        screen.blit(prompt_surface, prompt_rect)
+ 
+
+    if ball_moving:
+        ball.x += ball_speed_x
+        ball.y += ball_speed_y
+        if ball.top <= 0 or ball.bottom >= SCREEN_HEIGHT:
+            ball_speed_y *= -1
+        if ball.colliderect(paddle1) or ball.colliderect(paddle2):
+            ball_speed_x *= -1.05
+            ball_speed_y *= 1.05
+            if x > 0:
+                x -= x/10
+                BALL_COLOR = (255, x, 0)
+        if ball.left <= 0:
+            player_2_score += 1
+            x = 144
+            if deuce and player_2_score - player_1_score >= 2:
+                winner_text = "Player 2 Wins !"
+                game_over = True
+                deuce = False
+            if not deuce and player_2_score >= 11:
+                winner_text = "Player 2 Wins !"
+                game_over = True
+                deuce = False
+            if not deuce and player_1_score >= 10 and player_2_score >= 10:
+                deuce = True
+            ball.center = (SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2)
+            ball_moving = False
+        if ball.right >= SCREEN_WIDTH:
+            player_1_score += 1
+            x = 144
+            if deuce and player_1_score - player_2_score >= 2:
+                winner_text = "Player 1 Wins !"
+                game_over = True
+                deuce = False
+            if not deuce and player_1_score >= 11:
+                winner_text = "Player 1 Wins !"
+                game_over = True
+            if not deuce and player_1_score >= 10 and player_2_score >= 10:
+                deuce = True
+                deuce = False
+            ball.center = (SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2)
+            ball_moving = False
+    if game_over:
+        game_over_surface = title_font.render(winner_text, True, TEXT_COLOR)
+        game_over_rect = game_over_surface.get_rect(center = (SCREEN_WIDTH // 2 , SCREEN_HEIGHT // 2 -50))
+        screen.blit(game_over_surface, game_over_rect)
+
+        restart_surface = prompt_font.render("Press Space to Restart", True, TEXT_COLOR)
+        restart_rect = restart_surface.get_rect(center = (SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2 + 20))
+        screen.blit(restart_surface, restart_rect)
+
+    
+    if paddle1.top <= 0:
+        paddle1.top = 0
+    if paddle1.bottom >= SCREEN_HEIGHT:
+        paddle1.bottom = SCREEN_HEIGHT
+    if paddle2.top <= 0:
+        paddle2.top = 0
+    if paddle2.bottom >= SCREEN_HEIGHT:
+        paddle2.bottom = SCREEN_HEIGHT
+    pygame.display.flip()
+    clock.tick(60)
+
+pygame.quit()
+sys.exit()