Coin Colelctor

import pygame
import random
import os

# Initialize game components
def setup_game():
    pygame.init()
    display = pygame.display.set_mode((800, 600))
    pygame.display.set_caption('Coin Collector')
    
    # Load game assets
    game_assets = {}
    asset_paths = {
        'background': 'assets/bg.png',
        'character': 'assets/player.png',
        'coin': 'assets/coin.png'
    }
    
    for key, path in asset_paths.items():
        game_assets[key] = pygame.image.load(path)
    
    return display, game_assets

class Player:
    def __init__(self, image, start_pos):
        self.image = image
        self.position = list(start_pos)
        self.speed = 5
    
    def move(self, direction, screen_bounds):
        if direction == 'left':
            self.position[0] = max(0, self.position[0] - self.speed)
        elif direction == 'right':
            self.position[0] = min(screen_bounds[0] - self.image.get_width(), self.position[0] + self.speed)
    
    def draw(self, surface):
        surface.blit(self.image, self.position)

class Collectible:
    def __init__(self, image, value, screen_bounds):
        self.image = image
        self.value = value
        self.position = [random.randint(0, screen_bounds[0] - image.get_width()), -image.get_height()]
        self.fall_speed = random.randint(3, 7)
    
    def update(self):
        self.position[1] += self.fall_speed
        return self.position[1] > 600
    
    def draw(self, surface):
        surface.blit(self.image, self.position)

def run_game():
    screen, resources = setup_game()
    player = Player(resources['character'], (375, 500))
    collectibles = []
    score = 0
    
    clock = pygame.time.Clock()
    running = True
    
    while running:
        screen.blit(resources['background'], (0, 0))
        
        # Handle events
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
        
        # Process input
        keys = pygame.key.get_pressed()
        if keys[pygame.K_LEFT]:
            player.move('left', (800, 600))
        if keys[pygame.K_RIGHT]:
            player.move('right', (800, 600))
        
        # Generate collectibles
        if random.random() < 0.02:
            collectibles.append(Collectible(resources['coin'], 10, (800, 600)))
        
        # Update collectibles
        for item in collectibles[:]:
            if item.update():
                collectibles.remove(item)
            elif (abs(player.position[0] - item.position[0]) < 50 and 
                  abs(player.position[1] - item.position[1]) < 50):
                collectibles.remove(item)
                score += item.value
        
        # Draw game elements
        for item in collectibles:
            item.draw(screen)
        player.draw(screen)
        
        # Display score
        font = pygame.font.Font(None, 36)
        score_text = font.render(f'Score: {score}', True, (255, 255, 255))
        screen.blit(score_text, (10, 10))
        
        pygame.display.flip()
        clock.tick(60)
    
    pygame.quit()

if __name__ == '__main__':
    run_game()

Pong Game

import pygame
import sys

class Paddle:
    def __init__(self, x_pos, controls):
        self.rect = pygame.Rect(x_pos, 250, 15, 100)
        self.speed = 7
        self.controls = controls  # (up_key, down_key)
    
    def update(self, keys_pressed, screen_height):
        if keys_pressed[self.controls[0]]:
            self.rect.y = max(0, self.rect.y - self.speed)
        if keys_pressed[self.controls[1]]:
            self.rect.y = min(screen_height - self.rect.height, self.rect.y + self.speed)
    
    def draw(self, surface):
        pygame.draw.rect(surface, (255, 255, 255), self.rect)

class Ball:
    def __init__(self):
        self.rect = pygame.Rect(395, 295, 10, 10)
        self.velocity = [5, 5]
    
    def update(self, paddles, screen_size):
        self.rect.x += self.velocity[0]
        self.rect.y += self.velocity[1]
        
        # Wall collision
        if self.rect.top <= 0 or self.rect.bottom >= screen_size[1]:
            self.velocity[1] *= -1
        
        # Paddle collision
        for paddle in paddles:
            if self.rect.colliderect(paddle.rect):
                self.velocity[0] *= -1
                self.rect.x += self.velocity[0] * 2
        
        # Score detection
        if self.rect.left <= 0:
            return 'right'
        elif self.rect.right >= screen_size[0]:
            return 'left'
        return None
    
    def draw(self, surface):
        pygame.draw.rect(surface, (255, 255, 255), self.rect)

def main():
    pygame.init()
    screen = pygame.display.set_mode((800, 600))
    pygame.display.set_caption('Pong')
    
    left_paddle = Paddle(50, (pygame.K_w, pygame.K_s))
    right_paddle = Paddle(735, (pygame.K_UP, pygame.K_DOWN))
    ball = Ball()
    
    scores = [0, 0]
    font = pygame.font.Font(None, 74)
    
    clock = pygame.time.Clock()
    
    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
        
        keys = pygame.key.get_pressed()
        left_paddle.update(keys, 600)
        right_paddle.update(keys, 600)
        
        score_result = ball.update([left_paddle, right_paddle], (800, 600))
        if score_result == 'right':
            scores[1] += 1
            ball = Ball()
        elif score_result == 'left':
            scores[0] += 1
            ball = Ball()
        
        # Draw everything
        screen.fill((0, 0, 0))
        left_paddle.draw(screen)
        right_paddle.draw(screen)
        ball.draw(screen)
        
        # Draw scores
        left_text = font.render(str(scores[0]), True, (255, 255, 255))
        right_text = font.render(str(scores[1]), True, (255, 255, 255))
        screen.blit(left_text, (200, 10))
        screen.blit(right_text, (600, 10))
        
        pygame.display.flip()
        clock.tick(60)

if __name__ == '__main__':
    main()

Ski Adventure

import pygame
import random

class Skier:
    def __init__(self):
        self.images = [
            pygame.image.load('skier_up.png'),
            pygame.image.load('skier_right1.png'),
            pygame.image.load('skier_right2.png'),
            pygame.image.load('skier_left1.png'),
            pygame.image.load('skier_left2.png')
        ]
        self.direction = 0
        self.image = self.images[self.direction]
        self.rect = self.image.get_rect(center=(400, 100))
        self.speed = [0, 6]
    
    def turn(self, direction_change):
        self.direction = max(-2, min(2, self.direction + direction_change))
        self.image = self.images[self.direction]
        self.speed = [self.direction, 6 - abs(self.direction) * 2]
    
    def move(self):
        self.rect.centerx = max(20, min(780, self.rect.centerx + self.speed[0]))
    
    def draw(self, surface):
        surface.blit(self.image, self.rect)

class Obstacle:
    def __init__(self, image_path, position, obstacle_type):
        self.image = pygame.image.load(image_path)
        self.rect = self.image.get_rect(center=position)
        self.type = obstacle_type
        self.passed = False
    
    def update(self, scroll_amount):
        self.rect.centery += scroll_amount
    
    def draw(self, surface):
        surface.blit(self.image, self.rect)

def create_obstacles(num_obstacles):
    obstacles = []
    for _ in range(num_obstacles):
        pos_x = random.randint(0, 9) * 80 + 40
        pos_y = random.randint(0, 20) * 64 + 32
        obs_type = random.choice(['tree', 'flag'])
        img_path = f'obstacles/{obs_type}.png'
        obstacles.append(Obstacle(img_path, (pos_x, pos_y), obs_type))
    return obstacles

def main():
    pygame.init()
    screen = pygame.display.set_mode((800, 600))
    pygame.display.set_caption('Ski Adventure')
    
    skier = Skier()
    obstacles = create_obstacles(20)
    distance = 0
    score = 0
    
    clock = pygame.time.Clock()
    running = True
    
    while running:
        screen.fill((255, 255, 255))
        
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_LEFT:
                    skier.turn(-1)
                elif event.key == pygame.K_RIGHT:
                    skier.turn(1)
        
        skier.move()
        distance += skier.speed[1]
        
        # Update obstacles
        for obstacle in obstacles:
            obstacle.update(skier.speed[1])
            
            # Collision detection
            if obstacle.rect.colliderect(skier.rect) and not obstacle.passed:
                if obstacle.type == 'flag':
                    score += 10
                    obstacles.remove(obstacle)
                else:
                    score -= 50
                    obstacle.passed = True
        
        # Draw everything
        for obstacle in obstacles:
            obstacle.draw(screen)
        skier.draw(screen)
        
        # Display score
        font = pygame.font.Font(None, 36)
        score_text = font.render(f'Score: {score}', True, (0, 0, 0))
        screen.blit(score_text, (10, 10))
        
        pygame.display.flip()
        clock.tick(60)
    
    pygame.quit()

if __name__ == '__main__':
    main()