import socket import threading import pickle import pygame import sys import time HOST = '127.0.0.1' PORT = 65432 MOVE_SPEED = 200 # pixels per second class Event: def __init__(self, name, payload): self.name = name self.payload = payload def recvall(sock, n): data = b'' while len(data) < n: packet = sock.recv(n - len(data)) if not packet: return None data += packet return data def send_event(sock, event): data = pickle.dumps(event) length = len(data) sock.sendall(length.to_bytes(4, byteorder='big') + data) def recv_event(sock): raw_len = recvall(sock, 4) if not raw_len: return None msg_len = int.from_bytes(raw_len, byteorder='big') data = recvall(sock, msg_len) return pickle.loads(data) # Global state players = {} # Server-authoritative state: client_id -> {"username", "x", "y", "mouse_x", "mouse_y"} my_client_id = None # Our unique client id from the server predicted_state = { "x": 100, "y": 100, "keys": set(), "username": "Guest", "mouse_x": 0, "mouse_y": 0 } ping = 0 # measured ping in seconds server_details = {} # Updated from server_info and state_update events def listen_to_server(sock): global my_client_id, players, predicted_state, ping, server_details while True: try: event = recv_event(sock) if event is None: break if event.name == "self_id": if my_client_id is None: my_client_id = event.payload.get("client_id") print(f"[INFO] My client ID: {my_client_id}") elif event.name == "server_info": server_details = event.payload print(f"[INFO] Received server info: {server_details}") elif event.name == "client_connect": print(f"[INFO] Client connected: {event.payload.get('client_id')}") elif event.name == "client_disconnect": cid = event.payload.get("client_id") print(f"[INFO] Client disconnected: {cid}") if cid in players: del players[cid] elif event.name == "state_update": players = event.payload.get("players", {}) # Update dynamic server details. if "total_users" in event.payload: server_details["total_users"] = event.payload["total_users"] if "max_users" in event.payload: server_details["max_users"] = event.payload["max_users"] if my_client_id and my_client_id in players: server_x = players[my_client_id].get("x", 100) server_y = players[my_client_id].get("y", 100) tickrate = server_details.get("tickrate", 64) correction_factor = 0.1 * (64 / tickrate) if not predicted_state["keys"]: predicted_state["x"] = server_x predicted_state["y"] = server_y else: predicted_state["x"] += (server_x - predicted_state["x"]) * correction_factor predicted_state["y"] += (server_y - predicted_state["y"]) * correction_factor elif event.name == "pong": sent_time = event.payload.get("timestamp") if sent_time: round_trip = time.time() - sent_time ping = round_trip print(f"[PING] {ping*1000:.0f} ms") except Exception as e: print(f"[ERROR] {e}") break def send_message(sock, event): send_event(sock, event) def ping_loop(sock): while True: ts = time.time() send_message(sock, Event("ping", {"timestamp": ts})) time.sleep(1) def main(): global my_client_id, predicted_state username = input("Enter your username: ") predicted_state["username"] = username sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect((HOST, PORT)) threading.Thread(target=listen_to_server, args=(sock,), daemon=True).start() threading.Thread(target=ping_loop, args=(sock,), daemon=True).start() # Register for events. for event_name in ["client_connect", "client_disconnect", "state_update"]: send_message(sock, Event("register_event", {"event": event_name})) print(f"[INFO] Registered for event: {event_name}") send_message(sock, Event("set_username", {"username": username})) pygame.init() screen = pygame.display.set_mode((800, 600)) pygame.display.set_caption("Pygame Client - Multiplayer (Real vs Fake)") clock = pygame.time.Clock() ghost_color = (0, 255, 0) # Ghost: server state (outlined) client_color = (0, 0, 255) # Client: predicted state (filled) other_color = (255, 0, 0) # Remote players remote_mouse_color = (255, 255, 0) # Color for remote mouse pointer (yellow) local_keys = set() while True: dt = clock.tick(60) / 1000.0 for ev in pygame.event.get(): if ev.type == pygame.QUIT: pygame.quit() sys.exit() elif ev.type == pygame.KEYDOWN: key_name = None if ev.key == pygame.K_LEFT: key_name = "left" elif ev.key == pygame.K_RIGHT: key_name = "right" elif ev.key == pygame.K_UP: key_name = "up" elif ev.key == pygame.K_DOWN: key_name = "down" if key_name and key_name not in local_keys: local_keys.add(key_name) predicted_state["keys"].add(key_name) send_message(sock, Event("keydown", {"key": key_name})) elif ev.type == pygame.KEYUP: key_name = None if ev.key == pygame.K_LEFT: key_name = "left" elif ev.key == pygame.K_RIGHT: key_name = "right" elif ev.key == pygame.K_UP: key_name = "up" elif ev.key == pygame.K_DOWN: key_name = "down" if key_name and key_name in local_keys: local_keys.remove(key_name) if key_name in predicted_state["keys"]: predicted_state["keys"].remove(key_name) send_message(sock, Event("keyup", {"key": key_name})) elif ev.type == pygame.MOUSEMOTION: mouse_x, mouse_y = ev.pos predicted_state["mouse_x"] = mouse_x predicted_state["mouse_y"] = mouse_y send_message(sock, Event("mouse_move", {"x": mouse_x, "y": mouse_y})) # Update predicted state locally. dx, dy = 0, 0 if "left" in predicted_state["keys"]: dx -= MOVE_SPEED * dt if "right" in predicted_state["keys"]: dx += MOVE_SPEED * dt if "up" in predicted_state["keys"]: dy -= MOVE_SPEED * dt if "down" in predicted_state["keys"]: dy += MOVE_SPEED * dt predicted_state["x"] += dx predicted_state["y"] += dy # For our own player, the ghost (server) position is used as the "real" state. if my_client_id and my_client_id in players: ghost_x = players[my_client_id].get("x", 100) ghost_y = players[my_client_id].get("y", 100) else: ghost_x, ghost_y = predicted_state["x"], predicted_state["y"] screen.fill((0, 0, 0)) # Draw remote players (only real state). for cid, data in players.items(): if cid == my_client_id: continue x = int(data.get("x", 100)) y = int(data.get("y", 100)) uname = data.get("username", "Guest") pygame.draw.circle(screen, other_color, (x, y), 20) font = pygame.font.SysFont(None, 24) text_surface = font.render(uname, True, (255, 255, 255)) text_rect = text_surface.get_rect(center=(x, y - 30)) screen.blit(text_surface, text_rect) # Draw remote mouse pointer if available. if "mouse_x" in data and "mouse_y" in data: mx = int(data.get("mouse_x", 0)) my = int(data.get("mouse_y", 0)) pygame.draw.circle(screen, remote_mouse_color, (mx, my), 5) # Draw our ghost (server-authoritative) as an outlined circle. font = pygame.font.SysFont(None, 24) ghost_text = font.render("Ghost", True, (255, 255, 255)) ghost_rect = ghost_text.get_rect(center=(int(ghost_x), int(ghost_y) - 30)) pygame.draw.circle(screen, ghost_color, (int(ghost_x), int(ghost_y)), 20, 2) screen.blit(ghost_text, ghost_rect) # Draw our client-predicted player as a filled circle. pred_x = int(predicted_state.get("x", 100)) pred_y = int(predicted_state.get("y", 100)) font = pygame.font.SysFont(None, 24) client_text = font.render(predicted_state.get("username", "Guest"), True, (255, 255, 255)) client_rect = client_text.get_rect(center=(pred_x, pred_y - 30)) pygame.draw.circle(screen, client_color, (pred_x, pred_y), 20) screen.blit(client_text, client_rect) # Display ping. ping_font = pygame.font.SysFont(None, 24) ping_surface = ping_font.render(f"Ping: {int(ping*1000)} ms", True, (255, 255, 0)) screen.blit(ping_surface, (10, 10)) # Display HUD info: total users, client ID, and tickrate. hud_font = pygame.font.SysFont(None, 24) total_users = server_details.get("total_users", len(players)) max_users = server_details.get("max_users", "?") tickrate = server_details.get("tickrate", 64) hud_text = hud_font.render( f"Users: {total_users}/{max_users} | Client ID: {my_client_id or 'N/A'} | Tickrate: {tickrate} tps", True, (255, 255, 255) ) screen.blit(hud_text, (10, 40)) pygame.display.flip() if __name__ == "__main__": main()