small-projects/multiplyer-racing/main.py

#!/usr/bin/env python3
"""
A single-player pygame racing simulation where engine RPM and speed (in mph)
are modeled as independent—but coupled—systems. The engine’s RPM (tachometer)
is updated by throttle/brake input plus a damping effect that tends to “lock”
the engine to the value expected from the current vehicle speed and gear.
Vehicle acceleration is computed from the RPM difference (engine load)
minus drag, yielding a more realistic feel.

Controls:
  - LEFT/RIGHT arrows: steer
  - UP arrow: throttle (increases engine RPM and, via the dynamics, accelerates the car)
  - DOWN arrow: brake
  - E: upshift (gear +1 with rev-match drop)
  - Q: downshift (gear -1 with a slight rev bump)
  - R: toggle reverse (gear 0) versus forward (gear 1)
"""

import sys
import math
import random
import pygame

# ----- Screen & Road Configuration -----
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
ROAD_WIDTH = 150    # Road drawn as a wide filled polygon
FPS = 60

# ----- Engine & Vehicle Dynamics -----
IDLE_RPM = 800
REDLINE_RPM = 6000

# Engine dynamics (in rpm/sec)
THROTTLE_RPM_RATE = 8000    # When throttle is pressed, engine spins up
BRAKE_RPM_RATE = 2500      # When braking, engine RPM drops rapidly
DAMPING_FACTOR = 1         # How strongly engine RPM is forced toward the "ideal" RPM

# These dynamics model the connection between engine torque and vehicle acceleration:
# The vehicle's acceleration (in mph/s) is proportional to the difference between the
# current engine RPM and the ideal RPM that would be produced by the current speed in the given gear.
ACCELERATION_CONVERSION = 10   # (rpm difference) to mph/s conversion factor
DRAG_COEFF = 0.02               # Drag (per second) that always slows the vehicle

# Conversion constant (empirical) for what engine RPM should be for a given vehicle speed
# in a particular gear. In this model, ideal_rpm = speed × gear_ratio × K.
K = 0.1

# Maximum vehicle speed (in mph)
MAX_SPEED = 9000000

# ----- Transmission & Gear Ratios -----
# These gear ratios (including reverse = gear 0) are assumed to incorporate the effect
# of the transmission (and final drive) so that:
#    ideal_rpm = speed (mph) × gear_ratio × K.
GEAR_RATIOS = {
    0: 4.866,  # Reverse
    1: 4.696,
    2: 2.985,
    3: 2.146,
    4: 1.769,
    5: 1.520,
    6: 1.275,
    7: 1.000,
    8: 0.854,
    9: 0.689,
    10: 0.636
}

# Turning rate (radians per second)
TURN_RATE = 2.0

# ----- Gauge Configuration -----
GAUGE_RADIUS = 50
SPEED_GAUGE_CENTER = (150, 100)
TACH_GAUGE_CENTER = (650, 100)

# ----- Helper Functions -----
def rotate_point(point, angle):
    """Rotate a 2D point by angle in radians."""
    x, y = point
    cos_a = math.cos(angle)
    sin_a = math.sin(angle)
    return (x * cos_a - y * sin_a, x * sin_a + y * cos_a)

def draw_gauge(surface, center, radius, min_val, max_val, current_val, label):
    """
    Draw an analog gauge (circle with a needle) mapping a value from min_val to max_val
    to an angle between -135° and +135°.
    """
    pygame.draw.circle(surface, (255, 255, 255), center, radius, 2)
    min_angle = -135
    max_angle = 135
    ratio = (current_val - min_val) / (max_val - min_val) if max_val != min_val else 0
    angle_deg = min_angle + ratio * (max_angle - min_angle)
    angle_rad = math.radians(angle_deg)
    needle_length = radius - 10
    needle_end = (center[0] + needle_length * math.cos(angle_rad),
                  center[1] + needle_length * math.sin(angle_rad))
    pygame.draw.line(surface, (255, 0, 0), center, needle_end, 3)
    font = pygame.font.SysFont(None, 24)
    text_surf = font.render(f"{label}: {int(current_val)}", True, (255, 255, 255))
    text_rect = text_surf.get_rect(center=(center[0], center[1] + radius + 20))
    surface.blit(text_surf, text_rect)

def point_line_distance(P, A, B):
    """Return the shortest distance from point P to line segment AB."""
    AB = (B[0] - A[0], B[1] - A[1])
    AP = (P[0] - A[0], P[1] - A[1])
    ab2 = AB[0]**2 + AB[1]**2
    if ab2 == 0:
        return math.hypot(P[0] - A[0], P[1] - A[1])
    t = max(0, min(1, (AP[0]*AB[0] + AP[1]*AB[1]) / ab2))
    proj = (A[0] + t*AB[0], A[1] + t*AB[1])
    return math.hypot(P[0] - proj[0], P[1] - proj[1])

def closest_point_on_segment(P, A, B):
    """Return the closest point on line segment AB to point P."""
    AB = (B[0] - A[0], B[1] - A[1])
    AP = (P[0] - A[0], P[1] - A[1])
    ab2 = AB[0]**2 + AB[1]**2
    if ab2 == 0:
        return A
    t = max(0, min(1, (AP[0]*AB[0] + AP[1]*AB[1]) / ab2))
    return (A[0] + t * AB[0], A[1] + t * AB[1])

# ----- Game Objects -----
class Car:
    def __init__(self):
        self.x = 0.0      # Position (in feet or arbitrary units that scale to mph)
        self.y = 0.0
        self.angle = 0.0  # Orientation (radians; 0 means facing right)
        self.engine_rpm = IDLE_RPM
        self.gear = 1     # 0 = reverse, 1..10 forward
        self.speed = 0.0  # Vehicle speed in mph

    def update(self, throttle, brake, dt):
        """
        Update engine RPM and vehicle speed over time.
          - The engine RPM is updated based on throttle input, brake input, and a damping term that
            forces it toward the "ideal" RPM determined by the current speed.
          - The vehicle acceleration is then computed from the difference between actual and ideal RPM.
        """
        # Compute the ideal engine RPM given the current speed and gear.
        # For realism, if the car is stopped, ideal RPM should be at least IDLE_RPM.
        ideal_rpm = max(IDLE_RPM, self.speed * GEAR_RATIOS[self.gear] * K)

        # --- Engine RPM Dynamics ---
        throttle_effect = THROTTLE_RPM_RATE if throttle else 0
        brake_effect = BRAKE_RPM_RATE if brake else 0
        # Engine tends to return toward the ideal RPM.
        d_rpm = throttle_effect - brake_effect - DAMPING_FACTOR * (self.engine_rpm - ideal_rpm)
        self.engine_rpm += d_rpm * dt
        # Clamp engine RPM between IDLE and REDLINE.
        if self.engine_rpm < IDLE_RPM:
            self.engine_rpm = IDLE_RPM
        if self.engine_rpm > REDLINE_RPM:
            self.engine_rpm = REDLINE_RPM

        # --- Vehicle Acceleration Dynamics ---
        accel = (self.engine_rpm - ideal_rpm) / ACCELERATION_CONVERSION
        accel -= DRAG_COEFF * self.speed
        self.speed += accel * dt
        if self.speed < 0:
            self.speed = 0
        if self.speed > MAX_SPEED:
            self.speed = MAX_SPEED

        # --- Update Position ---
        direction = 1 if self.gear != 0 else -1
        ft_per_sec = self.speed * 1.46667  # Convert mph to ft/s
        self.x += math.cos(self.angle) * ft_per_sec * dt * direction
        self.y += math.sin(self.angle) * ft_per_sec * dt * direction

    def rev_match_on_shift_up(self):
        """Simulate a realistic drop in RPM when upshifting (rev-match)."""
        self.engine_rpm *= 0.85
        if self.engine_rpm < IDLE_RPM:
            self.engine_rpm = IDLE_RPM

    def rev_match_on_shift_down(self):
        """Simulate a realistic bump in RPM when downshifting."""
        self.engine_rpm *= 1.15
        if self.engine_rpm > REDLINE_RPM:
            self.engine_rpm = REDLINE_RPM

class Track:
    """
    A procedural track that extends as the car moves, giving the illusion of an infinite road.
    """
    def __init__(self):
        self.segments = []
        self.last_point = (0.0, 0.0)
        self.last_angle = 0.0
        self.generate_initial_track()

    def generate_initial_track(self):
        num_segments = 20
        for _ in range(num_segments):
            self.extend_segment()

    def extend_segment(self):
        length = 150
        angle_change = random.uniform(-0.3, 0.3)
        self.last_angle += angle_change
        dx = length * math.cos(self.last_angle)
        dy = length * math.sin(self.last_angle)
        next_point = (self.last_point[0] + dx, self.last_point[1] + dy)
        self.segments.append((self.last_point, next_point))
        self.last_point = next_point

    def ensure_track_length(self, car_pos, min_distance=500):
        dist = math.hypot(self.last_point[0] - car_pos[0], self.last_point[1] - car_pos[1])
        while dist < min_distance:
            self.extend_segment()
            dist = math.hypot(self.last_point[0] - car_pos[0], self.last_point[1] - car_pos[1])

def is_on_road(car, track, road_width):
    """
    Checks whether the car's center is within half the road width of any track segment.
    """
    P = (car.x, car.y)
    hw = road_width / 2
    for seg in track.segments:
        A, B = seg
        if point_line_distance(P, A, B) <= hw:
            return True
    return False

# ----- Drawing Functions -----
def draw_road(surface, track, offset_x, offset_y, road_width):
    """
    Draw each track segment as a filled polygon representing a wide road.
    """
    for seg in track.segments:
        start, end = seg
        dx = end[0] - start[0]
        dy = end[1] - start[1]
        seg_len = math.hypot(dx, dy)
        if seg_len == 0:
            continue
        nx = -dy / seg_len
        ny = dx / seg_len
        half_w = road_width / 2
        start_left  = (start[0] + nx * half_w, start[1] + ny * half_w)
        start_right = (start[0] - nx * half_w, start[1] - ny * half_w)
        end_left    = (end[0] + nx * half_w, end[1] + ny * half_w)
        end_right   = (end[0] - nx * half_w, end[1] - ny * half_w)
        poly = [
            (int(start_left[0] + offset_x), int(start_left[1] + offset_y)),
            (int(end_left[0] + offset_x), int(end_left[1] + offset_y)),
            (int(end_right[0] + offset_x), int(end_right[1] + offset_y)),
            (int(start_right[0] + offset_x), int(start_right[1] + offset_y))
        ]
        pygame.draw.polygon(surface, (100, 100, 100), poly)
        center_start = (start[0] + offset_x, start[1] + offset_y)
        center_end   = (end[0] + offset_x, end[1] + offset_y)
        pygame.draw.line(surface, (255, 255, 255), center_start, center_end, 2)

def draw_car(surface, car, offset_x, offset_y):
    """
    Draw the car as a rotated, car-like polygon.
    """
    center = (car.x + offset_x, car.y + offset_y)
    half_length = 40 / 2
    half_width = 20 / 2
    points = [
        ( half_length, 0),                # Front tip
        ( half_length * 0.2, -half_width),  # Rear top
        (-half_length, -half_width),       # Rear left
        (-half_length,  half_width),       # Rear right
        ( half_length * 0.2,  half_width)   # Rear bottom
    ]
    rotated = []
    for p in points:
        rp = rotate_point(p, car.angle)
        rotated.append((rp[0] + center[0], rp[1] + center[1]))
    pygame.draw.polygon(surface, (255, 0, 0), rotated)
    pygame.draw.polygon(surface, (255, 255, 255), rotated, 2)

def draw_map_view(surface, track, car):
    """
    Draw a mini-map in the bottom-right corner displaying all generated road segments
    and the car's current position.
    """
    map_width = 200
    map_height = 150
    map_x = SCREEN_WIDTH - map_width - 10
    map_y = SCREEN_HEIGHT - map_height - 10
    map_rect = pygame.Rect(map_x, map_y, map_width, map_height)

    # Draw mini-map background and border
    pygame.draw.rect(surface, (30, 30, 30), map_rect)
    pygame.draw.rect(surface, (255, 255, 255), map_rect, 2)
    
    # Compute bounding box for all track segments
    if track.segments:
        xs = []
        ys = []
        for seg in track.segments:
            A, B = seg
            xs.extend([A[0], B[0]])
            ys.extend([A[1], B[1]])
        min_x, max_x = min(xs), max(xs)
        min_y, max_y = min(ys), max(ys)
    else:
        min_x, max_x, min_y, max_y = 0, 1, 0, 1
    
    # Add margins
    margin = 10
    min_x -= margin
    min_y -= margin
    max_x += margin
    max_y += margin
    
    world_width = max_x - min_x
    world_height = max_y - min_y
    if world_width == 0 or world_height == 0:
        scale = 1
    else:
        scale = min((map_width - 20) / world_width, (map_height - 20) / world_height)
    
    # Convert world coordinates to mini-map coordinates
    def world_to_map(pos):
        world_x, world_y = pos
        map_pos_x = map_x + 10 + (world_x - min_x) * scale
        map_pos_y = map_y + 10 + (world_y - min_y) * scale
        return (int(map_pos_x), int(map_pos_y))
    
    # Draw road segments on mini-map
    for seg in track.segments:
        A, B = seg
        map_A = world_to_map(A)
        map_B = world_to_map(B)
        pygame.draw.line(surface, (200, 200, 200), map_A, map_B, 2)
    
    # Draw the car's current position as a small circle
    car_map_pos = world_to_map((car.x, car.y))
    pygame.draw.circle(surface, (255, 0, 0), car_map_pos, 4)

# ----- Main Game Loop -----
def main():
    pygame.init()
    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    pygame.display.set_caption("Super Realistic Car Simulation")
    clock = pygame.time.Clock()
    font = pygame.font.SysFont(None, 24)

    car = Car()
    track = Track()

    running = True
    while running:
        dt = clock.tick(FPS) / 1000.0

        # ----- Event Handling -----
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_e and car.gear < 10:
                    car.gear += 1
                    car.rev_match_on_shift_up()
                elif event.key == pygame.K_q and car.gear > 1:
                    car.gear -= 1
                    car.rev_match_on_shift_down()
                elif event.key == pygame.K_r:
                    if car.gear == 0:
                        car.gear = 1
                    else:
                        car.gear = 0

        # ----- Continuous Input -----
        keys = pygame.key.get_pressed()
        if keys[pygame.K_LEFT]:
            car.angle -= TURN_RATE * dt
        if keys[pygame.K_RIGHT]:
            car.angle += TURN_RATE * dt
        throttle = keys[pygame.K_UP]
        brake = keys[pygame.K_DOWN]

        # ----- Update Car & Extend Track -----
        car.update(throttle, brake, dt)
        track.ensure_track_length((car.x, car.y), min_distance=500)

        # Determine view offset to center the car.
        offset_x = SCREEN_WIDTH / 2 - car.x
        offset_y = SCREEN_HEIGHT / 2 - car.y

        # ----- Drawing -----
        screen.fill((0, 150, 0))  # Grass background.
        draw_road(screen, track, offset_x, offset_y, ROAD_WIDTH)
        draw_car(screen, car, offset_x, offset_y)

        # Display status (on-road/off-road)
        status_text = "On Road" if is_on_road(car, track, ROAD_WIDTH) else "Off Road"
        status_surf = font.render(status_text, True, (255, 255, 255))
        screen.blit(status_surf, (10, 10))

        # If off road, draw blue line to nearest point on road.
        if not is_on_road(car, track, ROAD_WIDTH):
            P = (car.x, car.y)
            min_distance = float('inf')
            closest_point = None
            for seg in track.segments:
                A, B = seg
                candidate = closest_point_on_segment(P, A, B)
                d = math.hypot(P[0] - candidate[0], P[1] - candidate[1])
                if d < min_distance:
                    min_distance = d
                    closest_point = candidate
            if closest_point is not None:
                start_screen = (int(car.x + offset_x), int(car.y + offset_y))
                end_screen = (int(closest_point[0] + offset_x), int(closest_point[1] + offset_y))
                pygame.draw.line(screen, (0, 0, 255), start_screen, end_screen, 2)

        # Draw gauges.
        draw_gauge(screen, SPEED_GAUGE_CENTER, GAUGE_RADIUS, 0, MAX_SPEED, car.speed, "Speed (mph)")
        draw_gauge(screen, TACH_GAUGE_CENTER, GAUGE_RADIUS, 0, REDLINE_RPM, car.engine_rpm, "RPM")

        # Display gear information.
        gear_text = "Reverse" if (car.gear == 0) else f"Gear: {car.gear}"
        gear_surf = font.render(gear_text, True, (255, 255, 255))
        screen.blit(gear_surf, (SPEED_GAUGE_CENTER[0] - GAUGE_RADIUS, SPEED_GAUGE_CENTER[1] + GAUGE_RADIUS + 40))

        # ----- Draw Map View -----
        draw_map_view(screen, track, car)

        pygame.display.flip()

    pygame.quit()
    sys.exit()

if __name__ == "__main__":
    main()