Event_Based_Server/server.py

import socket
import threading
import pickle
import time
import uuid
import math

HOST = '127.0.0.1'
PORT = 65432
TICKRATE = 128        # ticks per second (sub-tick simulation)
MAX_USERS = 100

# Racing physics constants.
ACCELERATION = 300.0        # pixels per second^2 (forward)
BRAKE_DECELERATION = 400.0  # pixels per second^2 (when braking)
FRICTION = 200.0            # pixels per second^2 (natural deceleration)
TURN_SPEED = math.radians(120)  # radians per second (steering)
MAX_SPEED = 400.0           # maximum forward speed (pixels/sec)
MIN_SPEED = -200.0          # maximum reverse speed (pixels/sec)

# Player appearance (for collision).
PLAYER_RADIUS = 20

# Define map obstacles.
map_obstacles = [
    {"x": 200, "y": 150, "width": 100, "height": 300},
    {"x": 500, "y": 100, "width": 50, "height": 400},
    {"x": 100, "y": 500, "width": 600, "height": 50},
]

def circle_rect_collision(cx, cy, radius, rect):
    closest_x = max(rect["x"], min(cx, rect["x"] + rect["width"]))
    closest_y = max(rect["y"], min(cy, rect["y"] + rect["height"]))
    dx = cx - closest_x
    dy = cy - closest_y
    return (dx * dx + dy * dy) < (radius * radius)

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 dictionaries.
event_subscriptions = {}   # event name -> list of client sockets
client_ids = {}            # conn -> client_id
# Each client state now stores position, angle, speed, and keys.
client_states = {}         # conn -> {"client_id", "username", "x", "y", "angle", "speed", "keys"}
lock = threading.Lock()

def handle_client(conn, addr):
    client_id = str(uuid.uuid4())
    with lock:
        client_ids[conn] = client_id
        client_states[conn] = {
            "client_id": client_id,
            "username": "Guest",
            "x": 100,
            "y": 100,
            "angle": 0,      # Facing right initially.
            "speed": 0,
            "keys": set()
        }
    print(f"[NEW CONNECTION] {addr} connected as {client_id}")
    
    try:
        send_event(conn, Event("self_id", {"client_id": client_id}))
        server_info = {
            "tickrate": TICKRATE,
            "total_users": len(client_states),
            "max_users": MAX_USERS,
            "server_ip": HOST,
            "server_port": PORT,
            "server_name": "My Top Down Racing Server",
            "map": map_obstacles
        }
        send_event(conn, Event("server_info", server_info))
    except Exception as e:
        print(f"[ERROR] sending self_id/server_info: {e}")
    
    broadcast_event("client_connect", {"client_id": client_id})
    
    try:
        while True:
            event = recv_event(conn)
            if event is None:
                break
            if event.name == "register_event":
                event_name = event.payload.get('event')
                with lock:
                    event_subscriptions.setdefault(event_name, []).append(conn)
                print(f"[REGISTER] {client_id} subscribed to '{event_name}'")
            elif event.name == "set_username":
                username = event.payload.get('username', 'Guest')
                with lock:
                    if conn in client_states:
                        client_states[conn]['username'] = username
                print(f"[USERNAME] {client_id} set username to '{username}'")
            elif event.name == "keydown":
                key = event.payload.get('key')
                with lock:
                    if conn in client_states:
                        client_states[conn]['keys'].add(key)
                print(f"[KEYDOWN] {client_id} key '{key}' pressed")
            elif event.name == "keyup":
                key = event.payload.get('key')
                with lock:
                    if conn in client_states and key in client_states[conn]['keys']:
                        client_states[conn]['keys'].remove(key)
                print(f"[KEYUP] {client_id} key '{key}' released")
            elif event.name == "ping":
                timestamp = event.payload.get('timestamp')
                send_event(conn, Event("pong", {"timestamp": timestamp}))
            # Any other events (e.g., mouse_move, shoot) are ignored for racing.
    except Exception as e:
        print(f"[ERROR] Exception with {client_ids.get(conn, 'unknown')}: {e}")
    finally:
        with lock:
            for subs in event_subscriptions.values():
                if conn in subs:
                    subs.remove(conn)
            client_ids.pop(conn, None)
            client_states.pop(conn, None)
        print(f"[DISCONNECT] {client_id} disconnected.")
        broadcast_event("client_disconnect", {"client_id": client_id})
        conn.close()

def broadcast_event(event_name, payload):
    event = Event(event_name, payload)
    with lock:
        receivers = event_subscriptions.get(event_name, [])
        for client in receivers[:]:
            try:
                send_event(client, event)
            except Exception as e:
                print(f"[ERROR] Failed to send to client, removing: {e}")
                receivers.remove(client)

def game_loop():
    dt = 1 / TICKRATE
    while True:
        time.sleep(dt)
        with lock:
            # Update each player's state using racing physics.
            for state in client_states.values():
                # Acceleration or braking.
                if 'up' in state['keys']:
                    state['speed'] += ACCELERATION * dt
                elif 'down' in state['keys']:
                    state['speed'] -= BRAKE_DECELERATION * dt
                else:
                    # Apply friction when no acceleration is active.
                    if state['speed'] > 0:
                        state['speed'] -= FRICTION * dt
                        if state['speed'] < 0:
                            state['speed'] = 0
                    elif state['speed'] < 0:
                        state['speed'] += FRICTION * dt
                        if state['speed'] > 0:
                            state['speed'] = 0

                # Clamp speed.
                if state['speed'] > MAX_SPEED:
                    state['speed'] = MAX_SPEED
                if state['speed'] < MIN_SPEED:
                    state['speed'] = MIN_SPEED

                # Steering.
                if 'left' in state['keys']:
                    state['angle'] -= TURN_SPEED * dt
                if 'right' in state['keys']:
                    state['angle'] += TURN_SPEED * dt

                # Compute new position.
                new_x = state['x'] + state['speed'] * math.cos(state['angle']) * dt
                new_y = state['y'] + state['speed'] * math.sin(state['angle']) * dt

                # Check collision with obstacles.
                collision = False
                for obs in map_obstacles:
                    if circle_rect_collision(new_x, new_y, PLAYER_RADIUS, obs):
                        collision = True
                        break
                if not collision:
                    state['x'] = new_x
                    state['y'] = new_y
                else:
                    # On collision, stop the car.
                    state['speed'] = 0

            # Build payload to send to all clients.
            players_payload = {}
            for state in client_states.values():
                players_payload[state['client_id']] = {
                    "username": state['username'],
                    "x": state['x'],
                    "y": state['y'],
                    "angle": state['angle'],
                    "speed": state['speed']
                }
            total_users = len(client_states)
            payload = {
                "players": players_payload,
                "total_users": total_users,
                "max_users": MAX_USERS
            }
        broadcast_event("state_update", payload)

def start_server():
    print("[STARTING] Server is starting...")
    threading.Thread(target=game_loop, daemon=True).start()
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        s.bind((HOST, PORT))
        s.listen()
        print(f"[LISTENING] Server is listening on {HOST}:{PORT}")
        while True:
            conn, addr = s.accept()
            threading.Thread(target=handle_client, args=(conn, addr), daemon=True).start()

if __name__ == "__main__":
    start_server()