Skip to content
The Chat Archive
o1-mini-2024-09-12· OpenAI WildChat-4.8M (AI2)

add bullets collsion to ground and tiles game.py import time import pygame import socket…

  1. User

    add bullets collsion to ground and tiles

    game.py

    import time import pygame import socket import pickle import threading import struct import sys import json

    Initialize Pygame

    pygame.init()

    Set up the screen

    SCREEN_WIDTH, SCREEN_HEIGHT = 1280, 720 screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT)) pygame.display.set_caption('2D Fight Game')

    Constants

    TILE_SIZE = 72 # Tile size after scaling GRAVITY = 1 JUMP_STRENGTH = 15 SPEED = 11 FRICTION = 0.0001 FONT = pygame.font.Font(None, 48) SMALL_FONT = pygame.font.Font(None, 36) WHITE = (255, 255, 255) BLACK = (46, 46, 46) BLUE = (135, 206, 235) RED = (255, 0, 0) GREEN = (0, 255, 0)

    Bullet settings

    MAX_BULLETS = 5 # Maximum number of bullets allowed on screen BULLET_COOLDOWN = 300 # Cooldown time in milliseconds between shots

    Input boxes

    player_name_input_box = pygame.Rect(400, 200, 400, 50) server_ip_input_box = pygame.Rect(400, 300, 400, 50)

    Text variables

    player_name = 'Player' server_ip = 'localhost' input_active = None

    Connecting flag

    connecting = False

    Function to display text

    def draw_text(text, font, color, surface, x, y): textobj = font.render(text, True, color) textrect = textobj.get_rect(center=(x, y)) surface.blit(textobj, textrect)

    Connecting screen

    def show_connecting_screen(): screen.fill(BLUE) draw_text("Connecting...", FONT, BLACK, screen, SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2) pygame.display.flip()

    Function to handle user input for name and server IP in Pygame

    def get_user_input_pygame(): global player_name, server_ip, input_active, connecting while True: for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() sys.exit() if event.type == pygame.MOUSEBUTTONDOWN: if player_name_input_box.collidepoint(event.pos): input_active = 'name' elif server_ip_input_box.collidepoint(event.pos): input_active = 'server_ip' else: input_active = None if event.type == pygame.KEYDOWN: if input_active == 'name': if event.key == pygame.K_RETURN: input_active = 'server_ip' elif event.key == pygame.K_BACKSPACE: player_name = player_name[:-1] else: player_name += event.unicode elif input_active == 'server_ip': if event.key == pygame.K_RETURN: connecting = True show_connecting_screen() return player_name, server_ip elif event.key == pygame.K_BACKSPACE: server_ip = server_ip[:-1] else: server_ip += event.unicode

        screen.fill(BLUE)
        draw_text("Enter Player Name:", FONT, BLACK, screen, SCREEN_WIDTH // 2, 160)
        draw_text("Enter Server IP (e.g., localhost:25566):", FONT, BLACK, screen, SCREEN_WIDTH // 2, 260)
    
        pygame.draw.rect(screen, WHITE, player_name_input_box, 2)
        pygame.draw.rect(screen, WHITE, server_ip_input_box, 2)
    
        draw_text(player_name, SMALL_FONT, BLACK, screen, player_name_input_box.centerx, player_name_input_box.centery)
        draw_text(server_ip, SMALL_FONT, BLACK, screen, server_ip_input_box.centerx, server_ip_input_box.centery)
    
        pygame.display.flip()
    

    Function to send data

    def send_data(data): serialized_data = pickle.dumps(data) length = len(serialized_data) try: client.sendall(struct.pack('>I', length) + serialized_data) except socket.error as e: print(f"Failed to send data to server: {e}")

    Function to receive messages

    def receive_message(conn): length_data = conn.recv(4) if len(length_data) < 4: raise Exception("Received incomplete length data")

    data_length = struct.unpack('>I', length_data)[0]
    data = b''
    while len(data) < data_length:
        packet = conn.recv(data_length - len(data))
        if not packet:
            raise Exception("Received incomplete data")
        data += packet
    return pickle.loads(data)
    

    Set up the character

    character = pygame.Rect(375, 375, 50, 50) # Initial position character_velocity_x = 0 character_velocity_y = 0 is_jumping = False

    Initialize player data and map layout

    players = {} map_layout = []

    Load tile images

    tile_images = { 0: pygame.Surface((TILE_SIZE, TILE_SIZE)), # Empty space 1: pygame.image.load('./assets/grass.png').convert_alpha(), # Grass tile (solid) 2: pygame.image.load('./assets/grass.png').convert_alpha(), # Grass tile (jump-through) }

    Scale the grass tile image

    tile_images[1] = pygame.transform.scale(tile_images[1], (TILE_SIZE, TILE_SIZE)) tile_images[2] = pygame.transform.scale(tile_images[2], (TILE_SIZE, TILE_SIZE))

    Set color for transparent tile (matching the screen background)

    tile_images[0].fill(BLUE) # Light blue to blend with background

    Function to check if the character is on the ground (on a grass tile)

    def is_on_ground(rect): rect.bottom += 1 # Temporarily move the rect down by 1 pixel for y in range(max(0, rect.bottom // TILE_SIZE), min(len(map_layout), (rect.bottom // TILE_SIZE) + 1)): for x in range(max(0, rect.left // TILE_SIZE), min(len(map_layout[y]), (rect.right // TILE_SIZE) + 1)): if map_layout[y][x] == 1 or map_layout[y][x] == 2: tile_rect = pygame.Rect(x * TILE_SIZE, y * TILE_SIZE, TILE_SIZE, TILE_SIZE) if rect.colliderect(tile_rect): rect.bottom -= 1 # Move the rect back up return True rect.bottom -= 1 # Move the rect back up return False

    Function to check and handle general collision with tiles

    def handle_tile_collisions(rect): global character_velocity_y, character_velocity_x, is_jumping

    # Check vertical collisions first (falling or jumping)
    for y in range(max(0, rect.top // TILE_SIZE), min(len(map_layout), (rect.bottom // TILE_SIZE) + 1)):
        for x in range(max(0, rect.left // TILE_SIZE), min(len(map_layout[y]), (rect.right // TILE_SIZE) + 1)):
            tile_id = map_layout[y][x]
            tile_rect = pygame.Rect(x * TILE_SIZE, y * TILE_SIZE, TILE_SIZE, TILE_SIZE)
    
            if rect.colliderect(tile_rect):
                if tile_id == 1:  # Solid tile
                    # Handle vertical collisions
                    if character_velocity_y > 0:  # Falling down
                        if rect.bottom > tile_rect.top and rect.bottom <= tile_rect.bottom:
                            rect.bottom = tile_rect.top
                            character_velocity_y = 0
                            is_jumping = False
                    elif character_velocity_y < 0:  # Jumping up
                        if rect.top < tile_rect.bottom and rect.top >= tile_rect.top:
                            rect.top = tile_rect.bottom
                            character_velocity_y = 0
    
                elif tile_id == 2:  # Jump-through tile
                    # Handle collision if falling onto the tile
                    if character_velocity_y > 0 and rect.bottom > tile_rect.top and rect.bottom <= tile_rect.bottom:
                        rect.bottom = tile_rect.top
                        character_velocity_y = 0
                        is_jumping = False
    
    # Check horizontal collisions after vertical collisions are resolved
    for y in range(max(0, rect.top // TILE_SIZE), min(len(map_layout), (rect.bottom // TILE_SIZE) + 1)):
        for x in range(max(0, rect.left // TILE_SIZE), min(len(map_layout[y]), (rect.right // TILE_SIZE) + 1)):
            tile_id = map_layout[y][x]
            tile_rect = pygame.Rect(x * TILE_SIZE, y * TILE_SIZE, TILE_SIZE, TILE_SIZE)
    
            if rect.colliderect(tile_rect):
                if tile_id == 1:  # Solid tile
                    # Handle horizontal collisions
                    if character_velocity_x > 0:  # Moving right
                        if rect.right > tile_rect.left and rect.right <= tile_rect.right:
                            rect.right = tile_rect.left
                            character_velocity_x = 0
                    elif character_velocity_x < 0:  # Moving left
                        if rect.left < tile_rect.right and rect.left >= tile_rect.left:
                            rect.left = tile_rect.right
    

    Networking setup

    player_name, server_ip = get_user_input_pygame()

    try: if ':' in server_ip: HOST, PORT = server_ip.split(':') PORT = int(PORT) else: HOST = server_ip PORT = 25566 except ValueError: HOST = 'localhost' PORT = 25566 except TypeError: HOST = 'localhost' PORT = 25566 except Exception as e: print(f"An error occurred: {e}") HOST = 'localhost' PORT = 25566

    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: client.connect((HOST, PORT)) # Send initial player data to the server send_data({'name': player_name, 'position': (character.x, character.y)}) except socket.error as e: print(f"Unable to connect to the server: {e}") sys.exit()

    def receive_data(): global players, map_layout, running while running: try: data = receive_message(client) players = data.get('players', {}) map_layout = data.get('map_layout', []) except Exception as e: print(f"Disconnected from server: {e}") running = False break

    Start a thread to receive data from the server

    running = True threading.Thread(target=receive_data, daemon=True).start()

    Bullet class to manage bullets

    class Bullet: def init(self, owner, position, direction): self.owner = owner # Tuple (IP, PORT) self.x, self.y = position self.direction = direction # 1 for right, -1 for left self.speed = 15 self.rect = pygame.Rect(self.x, self.y, 10, 5)

    def move(self):
        self.x += self.speed * self.direction
        self.rect.x = self.x
    
    def draw(self, surface):
        pygame.draw.rect(surface, RED, self.rect)
    

    List to store local bullets

    bullets = []

    Variables for bullet cooldown

    last_shot_time = 0 # Time when the last shot was fired

    Respawn variables

    is_dead = False respawn_time = 0 # Timestamp when respawn should occur

    Main game loop

    clock = pygame.time.Clock() while running: for event in pygame.event.get(): if event.type == pygame.QUIT: running = False

    # Get keys pressed
    keys = pygame.key.get_pressed()
    
    # Handle horizontal movement
    if not is_dead:
        if keys[pygame.K_LEFT]:
            character_velocity_x = -SPEED
        elif keys[pygame.K_RIGHT]:
            character_velocity_x = SPEED
        else:
            character_velocity_x *= FRICTION  # Apply friction when no key is pressed
    
        # Handle jumping
        if (keys[pygame.K_SPACE] or keys[pygame.K_UP] or keys[pygame.K_w]) and not is_jumping and is_on_ground(character):
            character_velocity_y = -JUMP_STRENGTH
            is_jumping = True
    
        # Handle shooting with bullet limit and cooldown
        current_time = pygame.time.get_ticks()
        if keys[pygame.K_f]:
            if (current_time - last_shot_time >= BULLET_COOLDOWN) and (len(bullets) < MAX_BULLETS):
                # Determine shooting direction based on movement
                if character_velocity_x >= 0:
                    direction = 1  # Right
                else:
                    direction = -1  # Left
                # Create a bullet at the front of the character
                bullet_x = character.x + character.width if direction == 1 else character.x - 10
                bullet_y = character.y + character.height // 2
                new_bullet = Bullet((client.getsockname()[0], client.getsockname()[1]), (bullet_x, bullet_y), direction)
                bullets.append(new_bullet)
                # Update the last shot time
                last_shot_time = current_time
    
        # Apply gravity
        character_velocity_y += GRAVITY
        character.x += character_velocity_x
        character.y += character_velocity_y
    
        # Check and handle collisions with tiles
        handle_tile_collisions(character)
    
        # Ensure character stays within screen bounds
        if character.left < 0:
            character.left = 0
        if character.right > SCREEN_WIDTH:
            character.right = SCREEN_WIDTH
        if character.top < 0:
            character.top = 0
        if character.bottom > SCREEN_HEIGHT:
            character.bottom = SCREEN_HEIGHT
    
        # Update bullets
        for bullet in bullets[:]:
            bullet.move()
            # Remove bullets that are off-screen
            if bullet.x < 0 or bullet.x > SCREEN_WIDTH:
                bullets.remove(bullet)
    
        # Send character position and bullets to server
        try:
            # Serialize bullet data
            bullet_data = [{'x': b.x, 'y': b.y, 'direction': b.direction} for b in bullets]
            send_data({'name': player_name, 'position': (character.x, character.y), 'bullets': bullet_data})
        except socket.error as e:
            print(f"Failed to send data to server: {e}")
            running = False
    
    # Handle respawn
    if is_dead and pygame.time.get_ticks() >= respawn_time:
        is_dead = False
        character.x, character.y = 375, 375
        character_velocity_x, character_velocity_y = 0, 0
        is_jumping = False
        bullets.clear()
        # Inform server about respawn
        send_data({'name': player_name, 'position': (character.x, character.y), 'respawn': True})
    
    # Draw everything
    screen.fill(BLUE)
    
    # Draw the map layout
    for y, row in enumerate(map_layout):
        for x, tile_id in enumerate(row):
            tile_image = tile_images.get(tile_id)
            if tile_image:
                screen.blit(tile_image, (x * TILE_SIZE, y * TILE_SIZE))
    
    # Draw all players
    for addr, info in players.items():
        pos = info['position']
        color = info['color']
        health = info.get('health', 100)
        player_rect = pygame.Rect(pos[0], pos[1], 50, 50)
        pygame.draw.rect(screen, color, player_rect)
        name = info.get('name', 'Unknown')
        text_surface = SMALL_FONT.render(name, True, BLACK)
        screen.blit(text_surface, (pos[0], pos[1] - 20))  # Display name above player
    
        # Draw health bar
        health_bar_width = 50
        health_bar_height = 5
        health_ratio = max(health / 100, 0)
        pygame.draw.rect(screen, RED, (pos[0], pos[1] - 10, health_bar_width, health_bar_height))
        pygame.draw.rect(screen, GREEN, (pos[0], pos[1] - 10, health_bar_width * health_ratio, health_bar_height))
    
    # Draw all bullets from other players
    for addr, info in players.items():
        for b in info.get('bullets', []):
            bullet_rect = pygame.Rect(b['x'], b['y'], 10, 5)
            pygame.draw.rect(screen, RED, bullet_rect)
    
    # Draw local bullets
    for bullet in bullets:
        bullet.draw(screen)
    
    # Update the display
    pygame.display.flip()
    
    # Cap the frame rate
    clock.tick(60)
    
    # Handle death and respawn if necessary
    for addr, info in players.items():
        if addr == client.getsockname() and info.get('health', 100) <= 0:
            if not is_dead:
                is_dead = True
                respawn_time = pygame.time.get_ticks() + 3000  # 3 seconds cooldown
                print("You have been eliminated! Respawning in 3 seconds...")
                # Reset local character position to server's value for consistency
                character.x, character.y = info.get('position', (375, 375))
                character_velocity_x, character_velocity_y = 0, 0
                is_jumping = False
    

    Close the client socket and quit Pygame

    client.close() pygame.quit()

  2. Assistant

    To add bullet collision with the ground and tiles in your game.py, you'll need to implement collision detection between each bullet and the tiles on the map. When a bullet collides with a solid tile (e.g., grass tiles in your case), the bullet should be removed from the screen.

    Below are the steps and the corresponding code modifications to achieve this:

    1. Define a Collision Detection Function for Bullets:

      Create a function that checks if a bullet's rectangle (pygame.Rect) collides with any solid tile on the map.

    2. Integrate Collision Detection into the Bullet Update Loop:

      After moving each bullet, use the collision detection function to determine if the bullet has collided with a tile. If so, remove the bullet from the active bullets list.

    3. Optional: Handle Bullet Collision with Players:

      If you want bullets to also affect players (e.g., reduce health), you can extend the collision detection to handle player hits. However, this step is optional based on your current requirement.

    Below is the modified game.py with the necessary changes highlighted and explained:

    # game.py
    import time
    import pygame
    import socket
    import pickle
    import threading
    import struct
    import sys
    import json
    
    # Initialize Pygame
    pygame.init()
    
    # Set up the screen
    SCREEN_WIDTH, SCREEN_HEIGHT = 1280, 720
    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    pygame.display.set_caption('2D Fight Game')
    
    # Constants
    TILE_SIZE = 72  # Tile size after scaling
    GRAVITY = 1
    JUMP_STRENGTH = 15
    SPEED = 11
    FRICTION = 0.0001
    FONT = pygame.font.Font(None, 48)
    SMALL_FONT = pygame.font.Font(None, 36)
    WHITE = (255, 255, 255)
    BLACK = (46, 46, 46)
    BLUE = (135, 206, 235)
    RED = (255, 0, 0)
    GREEN = (0, 255, 0)
    
    # Bullet settings
    MAX_BULLETS = 5          # Maximum number of bullets allowed on screen
    BULLET_COOLDOWN = 300    # Cooldown time in milliseconds between shots
    
    # Input boxes
    player_name_input_box = pygame.Rect(400, 200, 400, 50)
    server_ip_input_box = pygame.Rect(400, 300, 400, 50)
    
    # Text variables
    player_name = 'Player'
    server_ip = 'localhost'
    input_active = None
    
    # Connecting flag
    connecting = False
    
    # Function to display text
    def draw_text(text, font, color, surface, x, y):
        textobj = font.render(text, True, color)
        textrect = textobj.get_rect(center=(x, y))
        surface.blit(textobj, textrect)
    
    # Connecting screen
    def show_connecting_screen():
        screen.fill(BLUE)
        draw_text("Connecting...", FONT, BLACK, screen, SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2)
        pygame.display.flip()
    
    # Function to handle user input for name and server IP in Pygame
    def get_user_input_pygame():
        global player_name, server_ip, input_active, connecting
        while True:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    pygame.quit()
                    sys.exit()
                if event.type == pygame.MOUSEBUTTONDOWN:
                    if player_name_input_box.collidepoint(event.pos):
                        input_active = 'name'
                    elif server_ip_input_box.collidepoint(event.pos):
                        input_active = 'server_ip'
                    else:
                        input_active = None
                if event.type == pygame.KEYDOWN:
                    if input_active == 'name':
                        if event.key == pygame.K_RETURN:
                            input_active = 'server_ip'
                        elif event.key == pygame.K_BACKSPACE:
                            player_name = player_name[:-1]
                        else:
                            player_name += event.unicode
                    elif input_active == 'server_ip':
                        if event.key == pygame.K_RETURN:
                            connecting = True
                            show_connecting_screen()
                            return player_name, server_ip
                        elif event.key == pygame.K_BACKSPACE:
                            server_ip = server_ip[:-1]
                        else:
                            server_ip += event.unicode
    
            screen.fill(BLUE)
            draw_text("Enter Player Name:", FONT, BLACK, screen, SCREEN_WIDTH // 2, 160)
            draw_text("Enter Server IP (e.g., localhost:25566):", FONT, BLACK, screen, SCREEN_WIDTH // 2, 260)
    
            pygame.draw.rect(screen, WHITE, player_name_input_box, 2)
            pygame.draw.rect(screen, WHITE, server_ip_input_box, 2)
    
            draw_text(player_name, SMALL_FONT, BLACK, screen, player_name_input_box.centerx, player_name_input_box.centery)
            draw_text(server_ip, SMALL_FONT, BLACK, screen, server_ip_input_box.centerx, server_ip_input_box.centery)
    
            pygame.display.flip()
    
    # Function to send data
    def send_data(data):
        serialized_data = pickle.dumps(data)
        length = len(serialized_data)
        try:
            client.sendall(struct.pack('>I', length) + serialized_data)
        except socket.error as e:
            print(f"Failed to send data to server: {e}")
    
    # Function to receive messages
    def receive_message(conn):
        length_data = conn.recv(4)
        if len(length_data) < 4:
            raise Exception("Received incomplete length data")
    
        data_length = struct.unpack('>I', length_data)[0]
        data = b''
        while len(data) < data_length:
            packet = conn.recv(data_length - len(data))
            if not packet:
                raise Exception("Received incomplete data")
            data += packet
        return pickle.loads(data)
    
    # Set up the character
    character = pygame.Rect(375, 375, 50, 50)  # Initial position
    character_velocity_x = 0
    character_velocity_y = 0
    is_jumping = False
    
    # Initialize player data and map layout
    players = {}
    map_layout = []
    
    # Load tile images
    tile_images = {
        0: pygame.Surface((TILE_SIZE, TILE_SIZE)),  # Empty space
        1: pygame.image.load('./assets/grass.png').convert_alpha(),  # Grass tile (solid)
        2: pygame.image.load('./assets/grass.png').convert_alpha(),  # Grass tile (jump-through)
    }
    
    # Scale the grass tile image
    tile_images[1] = pygame.transform.scale(tile_images[1], (TILE_SIZE, TILE_SIZE))
    tile_images[2] = pygame.transform.scale(tile_images[2], (TILE_SIZE, TILE_SIZE))
    
    # Set color for transparent tile (matching the screen background)
    tile_images[0].fill(BLUE)  # Light blue to blend with background
    
    # Function to check if the character is on the ground (on a grass tile)
    def is_on_ground(rect):
        rect.bottom += 1  # Temporarily move the rect down by 1 pixel
        for y in range(max(0, rect.bottom // TILE_SIZE), min(len(map_layout), (rect.bottom // TILE_SIZE) + 1)):
            for x in range(max(0, rect.left // TILE_SIZE), min(len(map_layout[y]), (rect.right // TILE_SIZE) + 1)):
                if map_layout[y][x] == 1 or map_layout[y][x] == 2:
                    tile_rect = pygame.Rect(x * TILE_SIZE, y * TILE_SIZE, TILE_SIZE, TILE_SIZE)
                    if rect.colliderect(tile_rect):
                        rect.bottom -= 1  # Move the rect back up
                        return True
        rect.bottom -= 1  # Move the rect back up
        return False
    
    # Function to check and handle general collision with tiles
    def handle_tile_collisions(rect):
        global character_velocity_y, character_velocity_x, is_jumping
    
        # Check vertical collisions first (falling or jumping)
        for y in range(max(0, rect.top // TILE_SIZE), min(len(map_layout), (rect.bottom // TILE_SIZE) + 1)):
            for x in range(max(0, rect.left // TILE_SIZE), min(len(map_layout[y]), (rect.right // TILE_SIZE) + 1)):
                tile_id = map_layout[y][x]
                tile_rect = pygame.Rect(x * TILE_SIZE, y * TILE_SIZE, TILE_SIZE, TILE_SIZE)
    
                if rect.colliderect(tile_rect):
                    if tile_id == 1:  # Solid tile
                        # Handle vertical collisions
                        if character_velocity_y > 0:  # Falling down
                            if rect.bottom > tile_rect.top and rect.bottom <= tile_rect.bottom:
                                rect.bottom = tile_rect.top
                                character_velocity_y = 0
                                is_jumping = False
                        elif character_velocity_y < 0:  # Jumping up
                            if rect.top < tile_rect.bottom and rect.top >= tile_rect.top:
                                rect.top = tile_rect.bottom
                                character_velocity_y = 0
    
                    elif tile_id == 2:  # Jump-through tile
                        # Handle collision if falling onto the tile
                        if character_velocity_y > 0 and rect.bottom > tile_rect.top and rect.bottom <= tile_rect.bottom:
                            rect.bottom = tile_rect.top
                            character_velocity_y = 0
                            is_jumping = False
    
        # Check horizontal collisions after vertical collisions are resolved
        for y in range(max(0, rect.top // TILE_SIZE), min(len(map_layout), (rect.bottom // TILE_SIZE) + 1)):
            for x in range(max(0, rect.left // TILE_SIZE), min(len(map_layout[y]), (rect.right // TILE_SIZE) + 1)):
                tile_id = map_layout[y][x]
                tile_rect = pygame.Rect(x * TILE_SIZE, y * TILE_SIZE, TILE_SIZE, TILE_SIZE)
    
                if rect.colliderect(tile_rect):
                    if tile_id == 1:  # Solid tile
                        # Handle horizontal collisions
                        if character_velocity_x > 0:  # Moving right
                            if rect.right > tile_rect.left and rect.right <= tile_rect.right:
                                rect.right = tile_rect.left
                                character_velocity_x = 0
                        elif character_velocity_x < 0:  # Moving left
                            if rect.left < tile_rect.right and rect.left >= tile_rect.left:
                                rect.left = tile_rect.right
    
    # Networking setup
    player_name, server_ip = get_user_input_pygame()
    
    try:
        if ':' in server_ip:
            HOST, PORT = server_ip.split(':')
            PORT = int(PORT)
        else:
            HOST = server_ip
            PORT = 25566
    except ValueError:
        HOST = 'localhost'
        PORT = 25566
    except TypeError:
        HOST = 'localhost'
        PORT = 25566
    except Exception as e:
        print(f"An error occurred: {e}")
        HOST = 'localhost'
        PORT = 25566
    
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        client.connect((HOST, PORT))
        # Send initial player data to the server
        send_data({'name': player_name, 'position': (character.x, character.y)})
    except socket.error as e:
        print(f"Unable to connect to the server: {e}")
        sys.exit()
    
    def receive_data():
        global players, map_layout, running
        while running:
            try:
                data = receive_message(client)
                players = data.get('players', {})
                map_layout = data.get('map_layout', [])
            except Exception as e:
                print(f"Disconnected from server: {e}")
                running = False
                break
    
    # Start a thread to receive data from the server
    running = True
    threading.Thread(target=receive_data, daemon=True).start()
    
    # Bullet class to manage bullets
    class Bullet:
        def __init__(self, owner, position, direction):
            self.owner = owner  # Tuple (IP, PORT)
            self.x, self.y = position
            self.direction = direction  # 1 for right, -1 for left
            self.speed = 15
            self.rect = pygame.Rect(self.x, self.y, 10, 5)
    
        def move(self):
            self.x += self.speed * self.direction
            self.rect.x = self.x
    
        def draw(self, surface):
            pygame.draw.rect(surface, RED, self.rect)
    
    # List to store local bullets
    bullets = []
    
    # Variables for bullet cooldown
    last_shot_time = 0  # Time when the last shot was fired
    
    # Respawn variables
    is_dead = False
    respawn_time = 0  # Timestamp when respawn should occur
    
    # Function to check if a bullet collides with any solid tile
    def is_bullet_colliding(rect):
        # Get the range of tiles overlapped by the rect
        start_x = rect.left // TILE_SIZE
        end_x = rect.right // TILE_SIZE
        start_y = rect.top // TILE_SIZE
        end_y = rect.bottom // TILE_SIZE
    
        # Clamp to map bounds
        start_x = max(0, start_x)
        end_x = min(len(map_layout[0]) if map_layout else 0, end_x)
        start_y = max(0, start_y)
        end_y = min(len(map_layout), end_y)
    
        for y in range(start_y, end_y + 1):
            for x in range(start_x, end_x + 1):
                if y < len(map_layout) and x < len(map_layout[y]):
                    tile_id = map_layout[y][x]
                    if tile_id == 1 or tile_id == 2:
                        tile_rect = pygame.Rect(x * TILE_SIZE, y * TILE_SIZE, TILE_SIZE, TILE_SIZE)
                        if rect.colliderect(tile_rect):
                            return True
        return False
    
    # Main game loop
    clock = pygame.time.Clock()
    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
    
        # Get keys pressed
        keys = pygame.key.get_pressed()
    
        # Handle horizontal movement
        if not is_dead:
            if keys[pygame.K_LEFT]:
                character_velocity_x = -SPEED
            elif keys[pygame.K_RIGHT]:
                character_velocity_x = SPEED
            else:
                character_velocity_x *= FRICTION  # Apply friction when no key is pressed
    
            # Handle jumping
            if (keys[pygame.K_SPACE] or keys[pygame.K_UP] or keys[pygame.K_w]) and not is_jumping and is_on_ground(character):
                character_velocity_y = -JUMP_STRENGTH
                is_jumping = True
    
            # Handle shooting with bullet limit and cooldown
            current_time = pygame.time.get_ticks()
            if keys[pygame.K_f]:
                if (current_time - last_shot_time >= BULLET_COOLDOWN) and (len(bullets) < MAX_BULLETS):
                    # Determine shooting direction based on movement
                    if character_velocity_x >= 0:
                        direction = 1  # Right
                    else:
                        direction = -1  # Left
                    # Create a bullet at the front of the character
                    bullet_x = character.x + character.width if direction == 1 else character.x - 10
                    bullet_y = character.y + character.height // 2
                    new_bullet = Bullet((client.getsockname()[0], client.getsockname()[1]), (bullet_x, bullet_y), direction)
                    bullets.append(new_bullet)
                    # Update the last shot time
                    last_shot_time = current_time
    
            # Apply gravity
            character_velocity_y += GRAVITY
            character.x += character_velocity_x
            character.y += character_velocity_y
    
            # Check and handle collisions with tiles
            handle_tile_collisions(character)
    
            # Ensure character stays within screen bounds
            if character.left < 0:
                character.left = 0
            if character.right > SCREEN_WIDTH:
                character.right = SCREEN_WIDTH
            if character.top < 0:
                character.top = 0
            if character.bottom > SCREEN_HEIGHT:
                character.bottom = SCREEN_HEIGHT
    
            # Update bullets
            for bullet in bullets[:]:
                bullet.move()
    
                # Check collision with tiles
                if is_bullet_colliding(bullet.rect):
                    bullets.remove(bullet)
                    continue  # Skip to the next bullet
    
                # Remove bullets that are off-screen
                if bullet.x < 0 or bullet.x > SCREEN_WIDTH:
                    bullets.remove(bullet)
    
            # Send character position and bullets to server
            try:
                # Serialize bullet data
                bullet_data = [{'x': b.x, 'y': b.y, 'direction': b.direction} for b in bullets]
                send_data({'name': player_name, 'position': (character.x, character.y), 'bullets': bullet_data})
            except socket.error as e:
                print(f"Failed to send data to server: {e}")
                running = False
    
        # Handle respawn
        if is_dead and pygame.time.get_ticks() >= respawn_time:
            is_dead = False
            character.x, character.y = 375, 375
            character_velocity_x, character_velocity_y = 0, 0
            is_jumping = False
            bullets.clear()
            # Inform server about respawn
            send_data({'name': player_name, 'position': (character.x, character.y), 'respawn': True})
    
        # Draw everything
        screen.fill(BLUE)
    
        # Draw the map layout
        for y, row in enumerate(map_layout):
            for x, tile_id in enumerate(row):
                tile_image = tile_images.get(tile_id)
                if tile_image:
                    screen.blit(tile_image, (x * TILE_SIZE, y * TILE_SIZE))
    
        # Draw all players
        for addr, info in players.items():
            pos = info['position']
            color = info['color']
            health = info.get('health', 100)
            player_rect = pygame.Rect(pos[0], pos[1], 50, 50)
            pygame.draw.rect(screen, color, player_rect)
            name = info.get('name', 'Unknown')
            text_surface = SMALL_FONT.render(name, True, BLACK)
            screen.blit(text_surface, (pos[0], pos[1] - 20))  # Display name above player
    
            # Draw health bar
            health_bar_width = 50
            health_bar_height = 5
            health_ratio = max(health / 100, 0)
            pygame.draw.rect(screen, RED, (pos[0], pos[1] - 10, health_bar_width, health_bar_height))
            pygame.draw.rect(screen, GREEN, (pos[0], pos[1] - 10, health_bar_width * health_ratio, health_bar_height))
    
        # Draw all bullets from other players
        for addr, info in players.items():
            for b in info.get('bullets', []):
                bullet_rect = pygame.Rect(b['x'], b['y'], 10, 5)
                pygame.draw.rect(screen, RED, bullet_rect)
    
        # Draw local bullets
        for bullet in bullets:
            bullet.draw(screen)
    
        # Update the display
        pygame.display.flip()
    
        # Cap the frame rate
        clock.tick(60)
    
        # Handle death and respawn if necessary
        for addr, info in players.items():
            if addr == client.getsockname() and info.get('health', 100) <= 0:
                if not is_dead:
                    is_dead = True
                    respawn_time = pygame.time.get_ticks() + 3000  # 3 seconds cooldown
                    print("You have been eliminated! Respawning in 3 seconds...")
                    # Reset local character position to server's value for consistency
                    character.x, character.y = info.get('position', (375, 375))
                    character_velocity_x, character_velocity_y = 0, 0
                    is_jumping = False
    
    # Close the client socket and quit Pygame
    client.close()
    pygame.quit()
    

    Explanation of Changes

    1. Added is_bullet_colliding Function:

      # Function to check if a bullet collides with any solid tile
      def is_bullet_colliding(rect):
          # Get the range of tiles overlapped by the rect
          start_x = rect.left // TILE_SIZE
          end_x = rect.right // TILE_SIZE
          start_y = rect.top // TILE_SIZE
          end_y = rect.bottom // TILE_SIZE
      
          # Clamp to map bounds
          start_x = max(0, start_x)
          end_x = min(len(map_layout[0]) if map_layout else 0, end_x)
          start_y = max(0, start_y)
          end_y = min(len(map_layout), end_y)
      
          for y in range(start_y, end_y + 1):
              for x in range(start_x, end_x + 1):
                  if y < len(map_layout) and x < len(map_layout[y]):
                      tile_id = map_layout[y][x]
                      if tile_id == 1 or tile_id == 2:
                          tile_rect = pygame.Rect(x * TILE_SIZE, y * TILE_SIZE, TILE_SIZE, TILE_SIZE)
                          if rect.colliderect(tile_rect):
                              return True
          return False
      
      • Purpose: This function checks whether a given rectangle (rect), representing a bullet, collides with any solid tile on the map. It iterates through the tiles that the bullet overlaps and returns True if a collision is detected.
    2. Integrated Collision Detection into the Bullet Update Loop:

      # Update bullets
      for bullet in bullets[:]:
          bullet.move()
      
          # Check collision with tiles
          if is_bullet_colliding(bullet.rect):
              bullets.remove(bullet)
              continue  # Skip to the next bullet
      
          # Remove bullets that are off-screen
          if bullet.x < 0 or bullet.x > SCREEN_WIDTH:
              bullets.remove(bullet)
      
      • Explanation: After moving each bullet, the code checks if it collides with any solid tile using the is_bullet_colliding function. If a collision is detected, the bullet is removed from the bullets list, effectively making it disappear from the screen.
    3. Optional Enhancements:

      • Bullet Collision with Players: If you want bullets to also interact with players (e.g., reduce health upon hit), you can extend the collision detection to check if a bullet's rectangle collides with any player's rectangle. This would involve iterating through the players dictionary and checking for collisions, similar to how it's done with tiles.

      • Visual Feedback: You might want to add visual effects or sounds when a bullet collides with a tile or a player to enhance the gameplay experience.

    Additional Considerations

    • Performance Optimization:

      • The is_bullet_colliding function iterates through all overlapping tiles for each bullet, which is efficient for small maps but might become a performance bottleneck for larger maps with numerous bullets. Consider spatial partitioning techniques like quad-trees if performance becomes an issue.
    • Handling Bullet-Player Interaction:

      • If implementing collision with players, ensure synchronization between the client and server to manage player health and bullet states accurately.
    • Network Synchronization:

      • Since the game uses networking, ensure that bullet creation and removal events are properly synchronized across all clients to maintain consistency in the game state.

    By implementing the above changes, your bullets will now correctly detect and respond to collisions with the ground and tiles, enhancing the interactivity and realism of your 2D fight game.