Event_Based_Server/client.py

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()