Python汽车交通模拟：实现车辆停车/红灯后启动延迟功能

核心思路 #

要实现停车/红灯结束后的启动延迟，需给每辆车增加延迟状态跟踪能力：

• 标记车辆是否处于启动延迟阶段
• 记录剩余延迟时长
• 每个时间步更新延迟状态，仅当延迟结束后允许车辆移动

代码修改步骤 #

1. 更新Car类，添加延迟状态属性 #

在__init__方法中新增两个属性，用于跟踪启动延迟：

class Car:
    counter = 0

    def __init__(self, position, latency, back_position, length):
        self.position = position
        self.latency = latency
        self.back_position = back_position
        self.length = length
        self.allowed_to_move = True
        # 新增启动延迟相关属性
        self.in_start_delay = False  # 是否处于启动延迟中
        self.remaining_delay = 0     # 剩余延迟时间
        Car.counter += 1
        self.name = f"car{Car.counter}"

2. 触发启动延迟的时机 #

当车辆从禁止移动状态切换为允许移动状态时（比如红灯变绿后、前车离开后），启动延迟倒计时：

# 在设置allowed_to_move为True前，先保存之前的状态
prev_allowed = car.allowed_to_move
# 原有的allowed_to_move设置逻辑...
car.allowed_to_move = True
# 如果之前禁止移动，现在转为允许，则触发启动延迟
if not prev_allowed and car.allowed_to_move:
    car.in_start_delay = True
    car.remaining_delay = car.latency

3. 在时间步中处理延迟逻辑 #

每次循环处理车辆移动前，先更新延迟状态，延迟期间车辆不移动：

for i, car in enumerate(cars):
    if car.position >= 100:
        continue

    # 处理启动延迟
    if car.in_start_delay:
        car.remaining_delay -= 1
        print(f"{car.name} 启动延迟中，剩余 {car.remaining_delay} 个时间单位")
        if car.remaining_delay <= 0:
            car.in_start_delay = False
        # 延迟期间跳过移动逻辑
        continue

    # 原有的交通灯检查、allowed_to_move设置逻辑...

    # 允许移动且无延迟时执行移动
    if car.allowed_to_move:
        car.position += 1
        car.back_position += 1
        print(f"{car.name} moved to position {car.position}")

4. 完整修改后的代码 #

import random

class Car:
    counter = 0

    def __init__(self, position, latency, back_position, length):
        self.position = position
        self.latency = latency
        self.back_position = back_position
        self.length = length
        self.allowed_to_move = True
        # 新增启动延迟属性
        self.in_start_delay = False
        self.remaining_delay = 0
        Car.counter += 1
        self.name = f"car{Car.counter}"

num_cars = int(input("How many cars do you want to generate? "))

cars = []
for i in range(num_cars):
    if i == 0:
        position = 0
    else:
        position = cars[i-1].back_position - 1

    latency = 3
    length = random.randint(3, 5)
    back_position = position - length
    car = Car(position, latency, back_position, length)
    cars.append(car)

print(f"Generated {num_cars} cars with random positions, latencies, and lengths:")
for car in cars:
    print(f"{car.name} at position {car.position} with latency {car.latency} and length {car.length}")

position = 0
timer = 0

while True:
    # 检查所有车辆是否到达终点
    if all(car.position >= 100 for car in cars):
        print("All cars have reached the end of the track!")
        break

    position += 1
    timer += 1

    colors = [1] * 10 + [2] * 2 + [3] * 10 + [2] * 2
    color = colors[timer % len(colors)]
    if color == 1:
        traffic_color = "red"
    elif color == 2:
        traffic_color = "orange"
    else:
        traffic_color = "green"
    print(f"Number: {timer}, Traffic color: {traffic_color}")

    for i, car in enumerate(cars):
        if car.position >= 100:
            continue

        # 处理启动延迟逻辑
        if car.in_start_delay:
            car.remaining_delay -= 1
            print(f"{car.name} 启动延迟中，剩余 {car.remaining_delay} 个时间单位")
            if car.remaining_delay <= 0:
                car.in_start_delay = False
            continue

        # 保存之前的允许移动状态，用于判断是否触发延迟
        prev_allowed = car.allowed_to_move

        # 交通灯检查逻辑
        if position % 10 == 0 and position != 100:
            while traffic_color != "green":
                print(f"Number: {timer}, Waiting for green light...")
                timer += 1
                color = colors[timer % len(colors)]
                if color == 1:
                    traffic_color = "red"
                elif color == 2:
                    traffic_color = "orange"
                else:
                    traffic_color = "green"
                print(f"Number: {timer}, Traffic color: {traffic_color}")

            # 红灯变绿后设置允许移动，并触发延迟
            if traffic_color == "green":
                if i == 0:
                    car.allowed_to_move = True
                    if i+1 < len(cars):
                        cars[i+1].allowed_to_move = True
                elif i == len(cars) - 1:
                    car.allowed_to_move = True
                    cars[i-1].allowed_to_move = True
                else:
                    car.allowed_to_move = True
                    if cars[i-1].back_position != cars[i+1].position + 1:
                        cars[i-1].allowed_to_move = True
                        cars[i+1].allowed_to_move = True
                    else:
                        cars[i-1].allowed_to_move = False
                        cars[i+1].allowed_to_move = False
        else:
            # 非交通灯位置，默认允许移动
            car.allowed_to_move = True

        # 检查是否从禁止移动转为允许移动，触发启动延迟
        if not prev_allowed and car.allowed_to_move:
            car.in_start_delay = True
            car.remaining_delay = car.latency
            print(f"{car.name} 开始启动延迟，时长 {car.latency} 个时间单位")
            continue  # 延迟启动，本次不移动

        # 允许移动且无延迟时，执行移动
        if car.allowed_to_move:
            car.position += 1
            car.back_position += 1
            print(f"{car.name} moved to position {car.position}")

关键说明 #

• 延迟触发条件：仅当车辆从allowed_to_move=False切换为True时触发延迟，避免正常行驶中重复触发。
• 延迟状态更新：每个时间步减少剩余延迟时长，归0后解除延迟状态，车辆才可开始移动。
• 兼容性：保留原代码的交通灯逻辑和车辆跟随逻辑，仅新增延迟处理，不破坏原有功能。

内容的提问来源于stack exchange，提问作者Eneru