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