Connection and Simulation Management

def connect(method, *args, **kwargs):
    """
    Connect to physics server using specified method.
    
    Args:
        method (int): Connection method constant
            - p.GUI: Graphical interface with visualization
            - p.DIRECT: Direct in-process connection (fastest)
            - p.SHARED_MEMORY: Shared memory connection
            - p.TCP: TCP network connection
            - p.UDP: UDP network connection
        key (int, optional): Shared memory key for SHARED_MEMORY mode
        hostName (str, optional): Host name for TCP/UDP connections
        port (int, optional): Port number for TCP/UDP connections
        options (str, optional): Additional connection options
    
    Returns:
        int: Physics client ID (0 for first connection, incremented for additional)
    
    Raises:
        Exception: If connection fails or server is not available
    """

def disconnect(physicsClientId=0):
    """
    Disconnect from physics server and clean up resources.
    
    Args:
        physicsClientId (int, optional): Physics client ID. Defaults to 0.
    """

def getConnectionInfo(physicsClientId=0):
    """
    Get connection information for the specified client.
    
    Args:
        physicsClientId (int, optional): Physics client ID. Defaults to 0.
    
    Returns:
        dict: Connection information including method, server info, and status
    """

def isConnected(physicsClientId=0):
    """
    Check if client is connected to physics server.
    
    Args:
        physicsClientId (int, optional): Physics client ID. Defaults to 0.
    
    Returns:
        bool: True if connected, False otherwise
    """

def stepSimulation(physicsClientId=0):
    """
    Advance simulation by one time step using forward dynamics.
    
    Args:
        physicsClientId (int, optional): Physics client ID. Defaults to 0.
    
    Note:
        Call this function in a loop for continuous simulation.
        Time step size is controlled by setTimeStep().
    """

def setRealTimeSimulation(enableRealTimeSimulation, physicsClientId=0):
    """
    Enable or disable real-time simulation mode.
    
    Args:
        enableRealTimeSimulation (int): 1 to enable, 0 to disable
        physicsClientId (int, optional): Physics client ID. Defaults to 0.
    
    Note:
        In real-time mode, simulation runs automatically without explicit stepSimulation() calls.
        Disabled by default for deterministic stepped simulation.
    """

def resetSimulation(physicsClientId=0):
    """
    Reset simulation state and remove all objects from world.
    
    Args:
        physicsClientId (int, optional): Physics client ID. Defaults to 0.
    
    Note:
        This removes all bodies, constraints, and resets physics state.
        Gravity and other physics parameters are preserved.
    """

def performCollisionDetection(physicsClientId=0):
    """
    Update collision detection without advancing simulation time.
    
    Args:
        physicsClientId (int, optional): Physics client ID. Defaults to 0.
    
    Note:
        Useful for getting contact information without stepping dynamics.
        Automatically called by stepSimulation().
    """

def getAPIVersion(physicsClientId=0):
    """
    Get PyBullet API version number.
    
    Args:
        physicsClientId (int, optional): Physics client ID. Defaults to 0.
    
    Returns:
        int: API version number
    """

import pybullet as p
import time

# Connect to physics server with GUI
physicsClient = p.connect(p.GUI)

# Set up simulation environment
p.setGravity(0, 0, -10)
p.setTimeStep(1./240.)

# Load objects
planeId = p.loadURDF("plane.urdf")
cubeId = p.loadURDF("cube.urdf", [0, 0, 1])

# Run simulation loop
for i in range(1000):
    p.stepSimulation()
    time.sleep(1./240.)  # Real-time visualization

p.disconnect()

import pybullet as p

# Connect without GUI for maximum performance
physicsClient = p.connect(p.DIRECT)

# Fast simulation without visualization overhead
p.setGravity(0, 0, -10)
p.setTimeStep(1./240.)

# Load and simulate
robotId = p.loadURDF("robot.urdf")

# Fast simulation loop
for i in range(10000):
    p.stepSimulation()
    # No sleep needed - runs as fast as possible

p.disconnect()

import pybullet as p

# Create multiple physics clients
client1 = p.connect(p.DIRECT)
client2 = p.connect(p.GUI)

# Configure different simulations
p.setGravity(0, 0, -10, physicsClientId=client1)
p.setGravity(0, 0, -5, physicsClientId=client2)  # Different gravity

# Load objects in different clients
robot1 = p.loadURDF("robot.urdf", physicsClientId=client1)
robot2 = p.loadURDF("robot.urdf", physicsClientId=client2)

# Run parallel simulations
for i in range(1000):
    p.stepSimulation(physicsClientId=client1)
    p.stepSimulation(physicsClientId=client2)

p.disconnect(physicsClientId=client1)
p.disconnect(physicsClientId=client2)

import pybullet as p

# Connect to remote physics server via TCP
physicsClient = p.connect(p.TCP, hostName="192.168.1.100", port=6667)

if p.isConnected():
    print("Connected to remote server")
    
    # Normal simulation operations
    p.setGravity(0, 0, -10)
    # ... simulation code ...
    
    p.disconnect()
else:
    print("Failed to connect to server")

import pybullet as p

try:
    physicsClient = p.connect(p.GUI)
    if not p.isConnected():
        raise ConnectionError("Failed to connect to physics server")
    
    # Simulation code...
    
except Exception as e:
    print(f"Simulation error: {e}")
finally:
    if p.isConnected():
        p.disconnect()