3D Physics

var rigid_body = RigidBody3D.new()
add_child(rigid_body)

# Add visual mesh
var mesh_instance = MeshInstance3D.new()
mesh_instance.mesh = SphereMesh.new()
rigid_body.add_child(mesh_instance)

# Add collision shape (required!)
var collision_shape = CollisionShape3D.new()
collision_shape.shape = SphereShape3D.new()
rigid_body.add_child(collision_shape)

# Configure physics properties
rigid_body.mass = 2.0
rigid_body.gravity_scale = 1.0

# Set mass
rigid_body.mass = 5.0

# Custom inertia (auto-calculated by default)
rigid_body.inertia = Vector3(1.0, 1.0, 1.0)

# Custom center of mass
rigid_body.center_of_mass_mode = RigidBody3D.CENTER_OF_MASS_MODE_CUSTOM
rigid_body.center_of_mass = Vector3(0, -0.5, 0)

# Linear velocity (movement)
rigid_body.linear_velocity = Vector3(5, 0, 0)

# Angular velocity (rotation in radians/second)
rigid_body.angular_velocity = Vector3(0, PI, 0)

# Set axis velocity (useful for jumping)
rigid_body.set_axis_velocity(Vector3(0, 10, 0))  # Jump

# Linear damping (movement slowdown)
rigid_body.linear_damp = 0.5
rigid_body.linear_damp_mode = RigidBody3D.DAMP_MODE_COMBINE

# Angular damping (rotation slowdown)
rigid_body.angular_damp = 1.0
rigid_body.angular_damp_mode = RigidBody3D.DAMP_MODE_COMBINE

# Freeze the body (stop all physics)
rigid_body.freeze = true
rigid_body.freeze_mode = RigidBody3D.FREEZE_MODE_STATIC

# Lock rotation but allow movement
rigid_body.lock_rotation = true

# Enable contact monitoring
rigid_body.contact_monitor = true
rigid_body.max_contacts_reported = 4

# Connect to collision signals
rigid_body.body_entered.connect(_on_body_entered)
rigid_body.body_exited.connect(_on_body_exited)

func _on_body_entered(body):
    print("Collided with: ", body.name)

# Get colliding bodies
var bodies = rigid_body.get_colliding_bodies()
print("Contact count: ", rigid_body.get_contact_count())

extends RigidBody3D

func _ready():
    custom_integrator = true

func _integrate_forces(state: PhysicsDirectBodyState3D):
    # Custom physics behavior
    var force = Vector3(0, 10, 0)
    state.apply_central_force(force)
    
    # Access and modify state
    var velocity = state.linear_velocity
    state.linear_velocity = velocity * 0.99  # Custom damping

# Allow sleeping when not moving
rigid_body.can_sleep = true

# Check if sleeping
if rigid_body.sleeping:
    print("Body is asleep")

# Wake up the body
rigid_body.sleeping = false

var character = CharacterBody3D.new()
add_child(character)

# Add collision shape
var collision = CollisionShape3D.new()
collision.shape = CapsuleShape3D.new()
character.add_child(collision)

# Configure character properties
character.floor_max_angle = deg_to_rad(45)  # Max slope angle
character.floor_snap_length = 0.1  # Stick to floor

extends CharacterBody3D

const SPEED = 5.0
const JUMP_VELOCITY = 4.5

func _physics_process(delta):
    # Add gravity
    if not is_on_floor():
        velocity.y -= ProjectSettings.get_setting("physics/3d/default_gravity") * delta
    
    # Handle jump
    if Input.is_action_just_pressed("jump") and is_on_floor():
        velocity.y = JUMP_VELOCITY
    
    # Get input direction
    var input_dir = Input.get_vector("left", "right", "forward", "back")
    var direction = (transform.basis * Vector3(input_dir.x, 0, input_dir.y)).normalized()
    
    # Apply movement
    if direction:
        velocity.x = direction.x * SPEED
        velocity.z = direction.z * SPEED
    else:
        velocity.x = move_toward(velocity.x, 0, SPEED)
        velocity.z = move_toward(velocity.z, 0, SPEED)
    
    # Move the character
    move_and_slide()

# Check if on floor
if character.is_on_floor():
    print("On ground")

# Check if only on floor (not on wall too)
if character.is_on_floor_only():
    print("Only on floor")

# Get floor normal and angle
var floor_normal = character.get_floor_normal()
var floor_angle = character.get_floor_angle()
print("Floor angle: ", rad_to_deg(floor_angle))

# Check if touching wall
if character.is_on_wall():
    var wall_normal = character.get_wall_normal()
    print("Wall normal: ", wall_normal)

# Check if hitting ceiling
if character.is_on_ceiling():
    print("Hit ceiling")

# Get number of collisions
var collision_count = character.get_slide_collision_count()

# Get collision details
for i in range(collision_count):
    var collision = character.get_slide_collision(i)
    print("Collider: ", collision.get_collider())
    print("Normal: ", collision.get_normal())
    print("Position: ", collision.get_position())

# Get last collision
var last_collision = character.get_last_slide_collision()

# Grounded mode (for platformers)
character.motion_mode = CharacterBody3D.MOTION_MODE_GROUNDED
character.up_direction = Vector3.UP

# Floating mode (for space games)
character.motion_mode = CharacterBody3D.MOTION_MODE_FLOATING

# Stop on slopes
character.floor_stop_on_slope = true

# Constant speed on slopes
character.floor_constant_speed = true

# Block wall climbing
character.floor_block_on_wall = true

# Snap length for sticking to floor
character.floor_snap_length = 0.1

# Get platform velocity
var platform_vel = character.get_platform_velocity()
var platform_angular_vel = character.get_platform_angular_velocity()

# Configure platform layers
character.platform_floor_layers = 1  # Which layers are platforms
character.platform_wall_layers = 0

# What happens when leaving platform
character.platform_on_leave = CharacterBody3D.PLATFORM_ON_LEAVE_ADD_VELOCITY

var static_body = StaticBody3D.new()
add_child(static_body)

# Add collision shape
var collision = CollisionShape3D.new()
collision.shape = BoxShape3D.new()
static_body.add_child(collision)

# Add visual mesh
var mesh_instance = MeshInstance3D.new()
mesh_instance.mesh = BoxMesh.new()
static_body.add_child(mesh_instance)

# Conveyor belt (affects touching bodies)
static_body.constant_linear_velocity = Vector3(2, 0, 0)

# Rotating platform
static_body.constant_angular_velocity = Vector3(0, 1, 0)

# Box
var box = BoxShape3D.new()
box.size = Vector3(2, 1, 2)

# Sphere
var sphere = SphereShape3D.new()
sphere.radius = 1.0

# Capsule (good for characters)
var capsule = CapsuleShape3D.new()
capsule.radius = 0.5
capsule.height = 2.0

# Cylinder
var cylinder = CylinderShape3D.new()
cylinder.radius = 1.0
cylinder.height = 2.0

# Convex polygon (custom shape)
var convex = ConvexPolygonShape3D.new()

# Concave polygon (for static complex meshes)
var concave = ConcavePolygonShape3D.new()

var collision_shape = CollisionShape3D.new()
collision_shape.shape = CapsuleShape3D.new()
physics_body.add_child(collision_shape)

# Disable collision temporarily
collision_shape.disabled = true

# Re-enable
collision_shape.set_deferred("disabled", false)  # Use deferred for safety

# Custom debug color
collision_shape.debug_color = Color.RED

# Fill or wireframe
collision_shape.debug_fill = true

var physics_mat = PhysicsMaterial.new()

# Friction (0.0 = ice, 1.0 = sticky)
physics_mat.friction = 0.5

# Bounce (0.0 = no bounce, 1.0 = perfect bounce)
physics_mat.bounce = 0.3

# Apply to body
rigid_body.physics_material_override = physics_mat

var pin_joint = PinJoint3D.new()
add_child(pin_joint)
pin_joint.node_a = body_a.get_path()
pin_joint.node_b = body_b.get_path()

var hinge = HingeJoint3D.new()
add_child(hinge)
hinge.node_a = door.get_path()
hinge.node_b = frame.get_path()

# Configure limits
hinge.set_param(HingeJoint3D.PARAM_LIMIT_UPPER, deg_to_rad(90))
hinge.set_param(HingeJoint3D.PARAM_LIMIT_LOWER, deg_to_rad(0))
hinge.set_flag(HingeJoint3D.FLAG_USE_LIMIT, true)

var slider = SliderJoint3D.new()
add_child(slider)
slider.node_a = piston.get_path()
slider.node_b = cylinder.get_path()

var raycast = RayCast3D.new()
add_child(raycast)
raycast.target_position = Vector3(0, 0, -10)
raycast.enabled = true

# Check for collision
if raycast.is_colliding():
    var collision_point = raycast.get_collision_point()
    var collision_normal = raycast.get_collision_normal()
    var collider = raycast.get_collider()
    print("Hit: ", collider.name, " at ", collision_point)

func _physics_process(delta):
    var space_state = get_world_3d().direct_space_state
    
    var query = PhysicsRayQueryParameters3D.create(
        global_position,
        global_position + Vector3(0, 0, -10)
    )
    
    var result = space_state.intersect_ray(query)
    
    if result:
        print("Hit: ", result.collider)
        print("Position: ", result.position)
        print("Normal: ", result.normal)

var space_state = get_world_3d().direct_space_state

# Sphere cast
var query = PhysicsShapeQueryParameters3D.new()
var sphere = SphereShape3D.new()
sphere.radius = 0.5
query.shape = sphere
query.transform = global_transform

var result = space_state.intersect_shape(query)
for hit in result:
    print("Overlapping: ", hit.collider)

# Set collision layer (what layer this object is on)
physics_body.collision_layer = 0b00000001  # Layer 1

# Set collision mask (what layers this object collides with)
physics_body.collision_mask = 0b00000011  # Layers 1 and 2

# Helper methods
physics_body.set_collision_layer_value(1, true)
physics_body.set_collision_mask_value(2, true)

extends RigidBody3D

func _on_body_entered(body):
    if body.is_in_group("player"):
        # Give item to player
        body.add_item(self)
        queue_free()

extends RigidBody3D

var explosion_force = 1000.0
var explosion_radius = 5.0

func explode():
    var bodies = get_colliding_bodies()
    for body in bodies:
        if body is RigidBody3D:
            var direction = (body.global_position - global_position).normalized()
            var distance = global_position.distance_to(body.global_position)
            var strength = explosion_force * (1.0 - distance / explosion_radius)
            body.apply_central_impulse(direction * strength)

extends Area3D

var jump_force = 20.0

func _on_body_entered(body):
    if body is CharacterBody3D:
        body.velocity.y = jump_force