Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

import socket import threading import pickle import random # Configuración del servidor…

  1. User

    import socket import threading import pickle import random # Configuración del servidor HOST = '0.0.0.0' # Acepta conexiones desde cualquier interfaz PUERTO = 5555 # Estructuras para almacenar los datos de los jugadores posiciones_jugadores = {} lock = threading.Lock() # Variables para las monedas y puntuaciones coins = [] # Lista de posiciones de las monedas player_scores = {} # Diccionario para almacenar las puntuaciones de los jugadores # Dimensiones del juego ANCHO = 800 ALTO = 600 moneda_tamaño = 10 jugador_tamaño = 20 # Debes definir el tamaño del jugador aquí también def check_collision(pos1, pos2): # Comprobar si dos cuadrados se superponen return (pos1[0] < pos2[0] + moneda_tamaño and pos1[0] + jugador_tamaño > pos2[0] and pos1[1] < pos2[1] + moneda_tamaño and pos1[1] + jugador_tamaño > pos2[1]) def manejar_cliente(conn, addr, id_jugador): global posiciones_jugadores, coins, player_scores print(f"Jugador {id_jugador} conectado desde {addr}") conn.send(pickle.dumps(id_jugador)) # Enviar ID al cliente with lock: posiciones_jugadores[id_jugador] = [0, 0] # Posición inicial player_scores[id_jugador] = 0 # Puntuación inicial while True: try: datos = pickle.loads(conn.recv(1024)) if not datos: break # Actualizar posición del jugador with lock: posiciones_jugadores[id_jugador] = datos if len(posiciones_jugadores) >= 2: # Comprobar colisiones con las monedas for coin in coins[:]: # Usamos una copia de la lista if check_collision(posiciones_jugadores[id_jugador], coin): coins.remove(coin) # Eliminar la moneda recolectada player_scores[id_jugador] += 1 # Incrementar la puntuación del jugador # Generar una nueva moneda new_coin = [random.randint(0, ANCHO - moneda_tamaño), random.randint(0, ALTO - moneda_tamaño)] coins.append(new_coin) break # Salir del bucle después de recolectar una moneda # Construir el estado del juego game_state = { 'players': posiciones_jugadores, 'coins': coins, 'scores': player_scores, 'waiting': False # Indica que el juego ya inició } else: # Si hay menos de 2 jugadores, enviar un mensaje indicando que estamos esperando game_state = { 'waiting': True, 'message': 'Esperando a más jugadores para iniciar la partida...' } # Enviar el estado del juego al cliente conn.sendall(pickle.dumps(game_state)) except Exception as e: print(f"Ocurrió un error con el jugador {id_jugador}: {e}") break # Remover jugador al desconectarse with lock: del posiciones_jugadores[id_jugador] del player_scores[id_jugador] conn.close() print(f"Jugador {id_jugador} desconectado") def iniciar_servidor(): global coins # Generar monedas iniciales for _ in range(10): # Por ejemplo, crear 10 monedas coin_pos = [random.randint(0, ANCHO - moneda_tamaño), random.randint(0, ALTO - moneda_tamaño)] coins.append(coin_pos) servidor = socket.socket(socket.AF_INET, socket.SOCK_STREAM) servidor.bind((HOST, PUERTO)) servidor.listen() print("Servidor iniciado. Esperando jugadores...") id_jugador = 0 while True: conn, addr = servidor.accept() thread = threading.Thread(target=manejar_cliente, args=(conn, addr, id_jugador)) thread.start() id_jugador += 1 if name == "main": iniciar_servidor() como adapto el cliente al servidor import pygame import random import socket import pickle import threading # Conexión al servidor cliente = socket.socket(socket.AF_INET, socket.SOCK_STREAM) cliente.connect(('192.168.1.48', 5555)) # Reemplaza 'IP_DEL_SERVIDOR' con la dirección IP del servidor id_jugador = pickle.loads(cliente.recv(1024)) # Inicialización de Pygame pygame.init() # Configuración de la pantalla ANCHO = 800 ALTO = 600 pantalla = pygame.display.set_mode((ANCHO, ALTO)) pygame.display.set_caption("Recolector de Monedas - Multijugador") # Colores BLANCO = (255, 255, 255) NEGRO = (0, 0, 0) DORADO = (212, 175, 55) OTRO_JUGADOR = (0, 255, 0) moneda_tamaño = 10 jugador_tamaño = 20 # Asegúrate de que coincida con el servidor coins = [] player_scores = {} # Jugador jugador_tamaño = 20 posicion = [random.randint(0, ANCHO - jugador_tamaño), random.randint(0, ALTO - jugador_tamaño)] velocidad_jugador = 5 # Monedas (Ahora las controlará el servidor, simplificamos por ahora) ''' moneda_tamaño = 10 moneda_pos = [random.randint(0, ANCHO - moneda_tamaño), random.randint(0, ALTO - moneda_tamaño)] monedas_recolectadas = 0 ''' # Reloj reloj = pygame.time.Clock() tiempo_restante = 60 # Segundos # Fuente fuente = pygame.font.SysFont("Arial", 24) # Almacenar posiciones de otros jugadores posiciones_jugadores = {} # Función para recibir datos del servidor def recibir_datos(): global posiciones_jugadores, coins, player_scores while True: try: datos = pickle.loads(cliente.recv(4096)) posiciones_jugadores = datos['players'] coins = datos['coins'] player_scores = datos['scores'] except: break # Iniciar hilo de recepción de datos thread_receiving = threading.Thread(target=recibir_datos) thread_receiving.start() # Bucle principal ejecutando = True while ejecutando: for evento in pygame.event.get(): if evento.type == pygame.QUIT: ejecutando = False teclas = pygame.key.get_pressed() if teclas[pygame.K_LEFT]: posicion[0] -= velocidad_jugador if teclas[pygame.K_RIGHT]: posicion[0] += velocidad_jugador if teclas[pygame.K_UP]: posicion[1] -= velocidad_jugador if teclas[pygame.K_DOWN]: posicion[1] += velocidad_jugador for coin in coins: pygame.draw.rect(pantalla, DORADO, (coin[0], coin[1], moneda_tamaño, moneda_tamaño)) # Colisiones con los bordes posicion[0] = max(0, min(ANCHO - jugador_tamaño, posicion[0])) posicion[1] = max(0, min(ALTO - jugador_tamaño, posicion[1])) # Enviar nuestra posición al servidor try: cliente.sendall(pickle.dumps(posicion)) except: ejecutando = False print("Conexión perdida con el servidor") break # Mostrar puntuación score = player_scores.get(id_jugador, 0) texto_puntuacion = fuente.render(f"Puntuación: {score}", True, BLANCO) pantalla.blit(texto_puntuacion, (10, 10)) # Actualizar tiempo tiempo_transcurrido = reloj.tick(60) / 1000 # Convertir milisegundos a segundos tiempo_restante -= tiempo_transcurrido if tiempo_restante <= 0: ejecutando = False # Dibujar todo pantalla.fill(NEGRO) # Dibujar jugadores for id, pos in posiciones_jugadores.items(): if id == id_jugador: color = BLANCO # Nuestro jugador else: color = OTRO_JUGADOR # Otros jugadores pygame.draw.rect(pantalla, color, (pos[0], pos[1], jugador_tamaño, jugador_tamaño)) # Mostrar tiempo texto_tiempo = fuente.render(f"Tiempo: {int(tiempo_restante)}", True, BLANCO) pantalla.blit(texto_tiempo, (ANCHO - 150, 10)) pygame.display.flip() pygame.quit() cliente.close() print("Juego terminado")

  2. Assistant

    Para adaptar tu cliente al servidor que has proporcionado, es necesario asegurarse de que el cliente maneje correctamente los estados y datos que el servidor envía. En tu código actual, hay algunos aspectos que requieren ajustes para que la comunicación entre el cliente y el servidor sea consistente y funcional.

    A continuación, te detallo los pasos y modificaciones necesarias para adaptar tu cliente al servidor:

    1. Manejar el estado de "espera" enviado por el servidor

    En tu servidor, cuando hay menos de 2 jugadores conectados, se envía al cliente un estado de juego que incluye la clave 'waiting': True. Sin embargo, en el cliente, no estás manejando este caso, lo que puede llevar a errores al intentar acceder a 'players', 'coins' o 'scores' cuando no están presentes en los datos recibidos.

    Solución: Modifica la función recibir_datos() para manejar el estado de espera:

    # Variables globales para manejar el estado de espera
    waiting = False
    waiting_message = ''
    
    # Función para recibir datos del servidor
    def recibir_datos():
        global posiciones_jugadores, coins, player_scores, waiting, waiting_message
        while True:
            try:
                datos = pickle.loads(cliente.recv(4096))
                if datos.get('waiting'):
                    # Estamos esperando a más jugadores
                    waiting = True
                    waiting_message = datos.get('message', 'Esperando...')
                else:
                    waiting = False
                    posiciones_jugadores = datos['players']
                    coins = datos['coins']
                    player_scores = datos['scores']
            except:
                break
    

    2. Ajustar el bucle principal para manejar el estado de espera

    Ahora que el cliente sabe cuándo está en estado de espera, debes ajustar el bucle principal para que, cuando waiting sea True, muestre un mensaje de espera y no intente dibujar el juego (ya que no hay datos de jugadores o monedas).

    Modificación del bucle principal:

    # Bucle principal
    ejecutando = True
    while ejecutando:
        for evento in pygame.event.get():
            if evento.type == pygame.QUIT:
                ejecutando = False
    
        if not waiting:
            # Manejo de inputs del jugador
            teclas = pygame.key.get_pressed()
            if teclas[pygame.K_LEFT]:
                posicion[0] -= velocidad_jugador
            if teclas[pygame.K_RIGHT]:
                posicion[0] += velocidad_jugador
            if teclas[pygame.K_UP]:
                posicion[1] -= velocidad_jugador
            if teclas[pygame.K_DOWN]:
                posicion[1] += velocidad_jugador
    
            # Colisiones con los bordes
            posicion[0] = max(0, min(ANCHO - jugador_tamaño, posicion[0]))
            posicion[1] = max(0, min(ALTO - jugador_tamaño, posicion[1]))
    
            # Enviar nuestra posición al servidor
            try:
                cliente.sendall(pickle.dumps(posicion))
            except:
                ejecutando = False
                print("Conexión perdida con el servidor")
                break
    
            # Actualizar tiempo
            tiempo_transcurrido = reloj.tick(60) / 1000  # Convertir milisegundos a segundos
            tiempo_restante -= tiempo_transcurrido
            if tiempo_restante <= 0:
                ejecutando = False
    
            # Dibujar todo
            pantalla.fill(NEGRO)
    
            # Dibujar monedas
            for coin in coins:
                pygame.draw.rect(pantalla, DORADO, (coin[0], coin[1], moneda_tamaño, moneda_tamaño))
    
            # Dibujar jugadores
            for id, pos in posiciones_jugadores.items():
                if id == id_jugador:
                    color = BLANCO  # Nuestro jugador
                else:
                    color = OTRO_JUGADOR  # Otros jugadores
                pygame.draw.rect(pantalla, color, (pos[0], pos[1], jugador_tamaño, jugador_tamaño))
    
            # Mostrar puntuación
            score = player_scores.get(id_jugador, 0)
            texto_puntuacion = fuente.render(f"Puntuación: {score}", True, BLANCO)
            pantalla.blit(texto_puntuacion, (10, 10))
    
            # Mostrar tiempo
            texto_tiempo = fuente.render(f"Tiempo: {int(tiempo_restante)}", True, BLANCO)
            pantalla.blit(texto_tiempo, (ANCHO - 150, 10))
        else:
            # Mostrar mensaje de espera
            pantalla.fill(NEGRO)
            texto_espera = fuente.render(waiting_message, True, BLANCO)
            rect_texto = texto_espera.get_rect(center=(ANCHO//2, ALTO//2))
            pantalla.blit(texto_espera, rect_texto)
            pygame.display.flip()
            reloj.tick(10)  # Reducir el uso de CPU mientras esperamos
            continue  # Volver al inicio del bucle sin ejecutar el resto del código
    
        pygame.display.flip()
    

    3. Asegurar la sincronización de variables globales

    Al utilizar variables globales como waiting y waiting_message, es importante declararlas como globales dentro de las funciones que las modifican (como ya se hizo en recibir_datos()).

    4. Manejar excepciones y desconexiones

    En la función recibir_datos(), es buena práctica manejar las excepciones para evitar que cualquier error inesperado detenga el cliente. Ya está implementado un try-except, pero podrías añadir más detalles o logs para facilitar la depuración.

    5. Verificar la dirección IP y el puerto del servidor

    Asegúrate de que la dirección IP y el puerto en el cliente coincidan con los del servidor. En tu código:

    cliente.connect(('192.168.1.48', 5555))  # Reemplaza '192.168.1.48' con la dirección IP del servidor si es diferente
    

    6. Coincidencia de tamaños y configuraciones

    Verifica que las variables como ANCHO, ALTO, moneda_tamaño, y jugador_tamaño sean las mismas tanto en el servidor como en el cliente para evitar inconsistencias en la representación del juego.

    Código del cliente adaptado

    A continuación, te proporciono el código completo del cliente con las modificaciones mencionadas:

    import pygame
    import random
    import socket
    import pickle
    import threading
    
    # Conexión al servidor
    cliente = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    cliente.connect(('192.168.1.48', 5555))  # Reemplaza '192.168.1.48' con la dirección IP del servidor
    id_jugador = pickle.loads(cliente.recv(1024))
    
    # Inicialización de Pygame
    pygame.init()
    
    # Configuración de la pantalla
    ANCHO = 800
    ALTO = 600
    pantalla = pygame.display.set_mode((ANCHO, ALTO))
    pygame.display.set_caption("Recolector de Monedas - Multijugador")
    
    # Colores
    BLANCO = (255, 255, 255)
    NEGRO = (0, 0, 0)
    DORADO = (212, 175, 55)
    OTRO_JUGADOR = (0, 255, 0)
    moneda_tamaño = 10
    jugador_tamaño = 20  # Asegúrate de que coincida con el servidor
    coins = []
    player_scores = {}
    
    # Jugador
    posicion = [random.randint(0, ANCHO - jugador_tamaño), random.randint(0, ALTO - jugador_tamaño)]
    velocidad_jugador = 5
    
    # Reloj
    reloj = pygame.time.Clock()
    tiempo_restante = 60  # Segundos
    
    # Fuente
    fuente = pygame.font.SysFont("Arial", 24)
    
    # Almacenar posiciones de otros jugadores
    posiciones_jugadores = {}
    
    # Variables globales para manejar el estado de espera
    waiting = False
    waiting_message = ''
    
    # Función para recibir datos del servidor
    def recibir_datos():
        global posiciones_jugadores, coins, player_scores, waiting, waiting_message
        while True:
            try:
                datos = pickle.loads(cliente.recv(4096))
                if datos.get('waiting'):
                    # Estamos esperando a más jugadores
                    waiting = True
                    waiting_message = datos.get('message', 'Esperando...')
                else:
                    waiting = False
                    posiciones_jugadores = datos['players']
                    coins = datos['coins']
                    player_scores = datos['scores']
            except:
                break
    
    # Iniciar hilo de recepción de datos
    thread_receiving = threading.Thread(target=recibir_datos)
    thread_receiving.start()
    
    # Bucle principal
    ejecutando = True
    while ejecutando:
        for evento in pygame.event.get():
            if evento.type == pygame.QUIT:
                ejecutando = False
    
        if not waiting:
            # Manejo de inputs del jugador
            teclas = pygame.key.get_pressed()
            if teclas[pygame.K_LEFT]:
                posicion[0] -= velocidad_jugador
            if teclas[pygame.K_RIGHT]:
                posicion[0] += velocidad_jugador
            if teclas[pygame.K_UP]:
                posicion[1] -= velocidad_jugador
            if teclas[pygame.K_DOWN]:
                posicion[1] += velocidad_jugador
    
            # Colisiones con los bordes
            posicion[0] = max(0, min(ANCHO - jugador_tamaño, posicion[0]))
            posicion[1] = max(0, min(ALTO - jugador_tamaño, posicion[1]))
    
            # Enviar nuestra posición al servidor
            try:
                cliente.sendall(pickle.dumps(posicion))
            except:
                ejecutando = False
                print("Conexión perdida con el servidor")
                break
    
            # Actualizar tiempo
            tiempo_transcurrido = reloj.tick(60) / 1000  # Convertir milisegundos a segundos
            tiempo_restante -= tiempo_transcurrido
            if tiempo_restante <= 0:
                ejecutando = False
    
            # Dibujar todo
            pantalla.fill(NEGRO)
    
            # Dibujar monedas
            for coin in coins:
                pygame.draw.rect(pantalla, DORADO, (coin[0], coin[1], moneda_tamaño, moneda_tamaño))
    
            # Dibujar jugadores
            for id, pos in posiciones_jugadores.items():
                if id == id_jugador:
                    color = BLANCO  # Nuestro jugador
                else:
                    color = OTRO_JUGADOR  # Otros jugadores
                pygame.draw.rect(pantalla, color, (pos[0], pos[1], jugador_tamaño, jugador_tamaño))
    
            # Mostrar puntuación
            score = player_scores.get(id_jugador, 0)
            texto_puntuacion = fuente.render(f"Puntuación: {score}", True, BLANCO)
            pantalla.blit(texto_puntuacion, (10, 10))
    
            # Mostrar tiempo
            texto_tiempo = fuente.render(f"Tiempo: {int(tiempo_restante)}", True, BLANCO)
            pantalla.blit(texto_tiempo, (ANCHO - 150, 10))
        else:
            # Mostrar mensaje de espera
            pantalla.fill(NEGRO)
            texto_espera = fuente.render(waiting_message, True, BLANCO)
            rect_texto = texto_espera.get_rect(center=(ANCHO//2, ALTO//2))
            pantalla.blit(texto_espera, rect_texto)
            pygame.display.flip()
            reloj.tick(10)  # Reducir el uso de CPU mientras esperamos
            continue  # Volver al inicio del bucle sin ejecutar el resto del código
    
        pygame.display.flip()
    
    pygame.quit()
    cliente.close()
    print("Juego terminado")
    

    Notas adicionales

    • Sincronización de datos: Asegúrate de que las estructuras de datos enviadas y recibidas entre el cliente y el servidor sean consistentes y estén correctamente serializadas con pickle.
    • Depuración: Utiliza print() u otras herramientas de depuración para monitorear el flujo de datos y detectar posibles errores.
    • Mejoras: Considera implementar mecanismos para reconectar al servidor en caso de desconexión o para manejar de forma más elegante las excepciones.

    Con estas modificaciones, tu cliente debería poder comunicarse adecuadamente con el servidor y reflejar el estado del juego de forma correcta. Si encuentras más problemas, te recomiendo revisar los logs tanto del cliente como del servidor para identificar y solucionar cualquier otro detalle.