Godot 2d Physics

# Collision Bitmask Helper
extends Node

## Managing bitmasks logically instead of hardcoding integers.
## Use constants and shift operators to keep complex faction systems readable.

enum Faction { NONE = 0, PLAYER = 1, ENEMY = 2, PROJECTILE = 3, WORLD = 4 }

func setup_actor_collision(node: CollisionObject2D, faction: Faction) -> void:
    # Clear current layers and masks
    node.collision_layer = 0
    node.collision_mask = 0
    
    # Set layer (What am I?)
    node.set_collision_layer_value(faction, true)
    
    # Set mask (What do I hit?)
    match faction:
        Faction.PLAYER:
            node.set_collision_mask_value(Faction.ENEMY, true)
            node.set_collision_mask_value(Faction.WORLD, true)
        Faction.PROJECTILE:
            node.set_collision_mask_value(Faction.ENEMY, true)
            node.set_collision_mask_value(Faction.PLAYER, true)

# Collision Signal Debouncer
extends Node

## Expert Pattern: Prevents "signal spam" when multiple collision shapes 
## on one body enter an Area2D simultaneously.

var _active_bodies: Dictionary = {}

func handle_body_entered(body: Node2D) -> void:
	if _active_bodies.has(body):
		return
		
	_active_bodies[body] = true
	print("Physics Body genuinely entered: ", body.name)

func handle_body_exited(body: Node2D) -> void:
	# Small delay or frame-check to ensure it's not a momentary exit/re-entry
	_active_bodies.erase(body)

# collision_layer_matrix_manager.gd
# Advanced collision layer/mask management logic
extends Node

# EXPERT NOTE: Use Bit-shifting or Enums for collision layers 
# rather than magic numbers to prevent 'Collision Matrix Hell'.

enum Layer {
	WORLD = 1,
	PLAYER = 2,
	ENEMY = 4,
	PROJECTILE = 8,
	HAZARD = 16
}

func setup_projectile(node: CollisionObject2D):
	# Projectiles should be on PROJECTILE layer (8)
	# And mask for WORLD (1) and ENEMY (4)
	node.collision_layer = Layer.PROJECTILE
	node.collision_mask = Layer.WORLD | Layer.ENEMY

func set_ignore_player(node: CollisionObject2D, ignore: bool):
	if ignore:
		node.collision_mask &= ~Layer.PLAYER # Bitwise NOT and AND to remove
	else:
		node.collision_mask |= Layer.PLAYER # Bitwise OR to add

# skills/2d-physics/code/collision_setup.gd
extends Node

## Collision Matrix & CCD Professional Standard

# --- 1. Recommended Layer Map ---
# Configure these in Project Settings -> Layer Names -> 2D Physics
enum CollisionLayer {
    WORLD = 1,      # Static environment
    PLAYER = 2,     # Player Character
    ENEMIES = 4,    # Enemy Characters
    PROJECTILES = 8,# High-speed bullets (Use CCD)
    HURTBOXES = 16, # Area2Ds for damage detection
    INTERACTABLES = 32
}

# --- 2. Continuous Collision Detection (CCD) ---
func setup_bullet(bullet: RigidBody2D) -> void:
    # REQUIRED for small, fast objects to prevent 'tunneling'
    bullet.continuous_cd = RigidBody2D.CCD_MODE_CAST_RAY
    
    # Also set collision mask to only hit what it needs to
    bullet.collision_mask = CollisionLayer.WORLD | CollisionLayer.ENEMIES

# --- 3. Optimization Tip ---
# Disable 'Contact Monitor' unless you actually need the 'body_entered' signal.
# RigidBody2D 'move_and_collide' is more performant than signal-based detection 
# for hundreds of active projectiles.

# continuous_collision_detection.gd
# Managing CCD for high-speed projectiles to prevent tunneling
extends RigidBody2D

# PROBLEM: High-speed bullets can skip through thin walls between frames.
# SOLUTION: Enable Continuous Collision Detection (CCD).

func _ready() -> void:
	# CCD_MODE_CAST_RAY is usually enough for most projectiles
	# CCD_MODE_CAST_SHAPE is the most accurate but expensive
	continuous_cd = RigidBody2D.CCD_MODE_CAST_RAY
	
	# Optimization: Only use CCD for high-speed phases
	contact_monitor = true
	max_contacts_reported = 1

# custom_gravity_area.gd
# Implementing custom gravity wells and directional zones
extends Area2D

# Expert: Using Area2D 'Priority' and 'Gravity' overrides.

func _ready() -> void:
	# High priority ensures this gravity overrides the global world gravity
	gravity_space_override = Area2D.SPACE_OVERRIDE_REPLACE
	gravity_point = true
	gravity_point_unit_distance = 100.0
	gravity = 980.0 # Attraction force
	
	# For directional gravity (e.g. anti-gravity lift)
	# gravity_space_override = Area2D.SPACE_OVERRIDE_REPLACE
	# gravity_direction = Vector2.UP

# Custom Physics Body Gravity Override
extends CharacterBody2D

## Pattern for localized gravity overrides (Space, Water, Wind).
## Bypasses global physics settings for specialized character movement.

@export var local_gravity := Vector2(0, 400)
@export var drag_factor := 0.95

func _physics_process(delta: float) -> void:
	# Ignore default project settings gravity
	velocity += local_gravity * delta
	
	# Apply fluid drag/friction
	velocity *= pow(drag_factor, delta * 60.0)
	
	move_and_slide()

# skills/2d-physics/scripts/custom_physics_2d.gd
extends CharacterBody2D

## Custom Physics 2D (Expert Pattern)
## Template for platformers requiring custom gravity/dashing/states without FSM overhead.
## Demonstrates use of `move_and_slide` with external forces.

class_name CustomPhysics2D

@export var gravity: float = 980.0
@export var jump_force: float = -400.0
@export var speed: float = 300.0

var external_force: Vector2 = Vector2.ZERO

func _physics_process(delta: float) -> void:
    # 1. Apply Gravity
    if not is_on_floor():
        velocity.y += gravity * delta
    else:
        velocity.y = 0.0 # Reset accum
        
    # 2. Input
    var dir = Input.get_axis("ui_left", "ui_right")
    if dir:
        velocity.x = dir * speed
    else:
        velocity.x = move_toward(velocity.x, 0, speed * delta * 5.0) # Friction
        
    if Input.is_action_just_pressed("ui_accept") and is_on_floor():
        velocity.y = jump_force
        
    # 3. Apply External Forces (Knockback)
    velocity += external_force * delta
    external_force = external_force.move_toward(Vector2.ZERO, 1000.0 * delta)
    
    # 4. Move
    move_and_slide()

func apply_knockback(force: Vector2) -> void:
    # Set immediate velocity? Or Add to external force?
    # Instant velocity change is usually snappier for hits
    velocity += force 

## EXPERT USAGE:
## Extend for PlayerController.

# skills/2d-physics/code/custom_physics.gd
extends RigidBody2D

## Deterministic Solver & Custom Gravity Pattern
## Demonstrates _integrate_forces for absolute control over physics state.

@export var custom_gravity_scale := 1.0
@export var local_gravity_center: Node2D

func _integrate_forces(state: PhysicsDirectBodyState2D) -> void:
    # --- 1. Custom Movement Math ---
    # Override velocity directly while remaining in the physics solver
    # This prevents 'jitter' compared to manual position changes
    
    var current_vel := state.linear_velocity
    # Apply custom dampening or acceleration
    # current_vel.x = move_toward(current_vel.x, target_speed, accel * state.step)
    
    # --- 2. Localized Gravity Fields ---
    if local_gravity_center:
        var dir := global_position.direction_to(local_gravity_center.global_position)
        var force := dir * 9.8 * custom_gravity_scale
        state.apply_central_force(force)
        
    # --- 3. Deterministic Stop ---
    if should_stop_instantly():
        state.linear_velocity = Vector2.ZERO
        state.angular_velocity = 0

func should_stop_instantly() -> bool:
    return false

## EXPERT NOTE:
## Always use 'state.step' for delta-consistency in _integrate_forces.
## This function is called during the physics synchronization phase, 
## making it the correct place for custom physics engines or character controllers
## that require RigidBody interactions without the 'floatiness' of default physics.

# Physics Interpolation and Jitter Controller
extends Node

## Godot 4 standard physics run at 60Hz, while monitors run at 144Hz+.
## This script ensures smooth visuals by enabling interpolation and 
## managing physics/render process synchronization.

func _ready() -> void:
	# Architecture Tip: Enable 'Physics Interpolation' in Project Settings.
	# This script ensures that crucial camera and player nodes are optimized
	# for that interpolation.
	
	if Engine.is_editor_hint(): return
	
	# Lock FPS to refresh rate to prevent visual 'beat' patterns against physics
	DisplayServer.window_set_vsync_mode(DisplayServer.VSYNC_ENABLED)
	
	# Low latency input mode for competitive physics feel
	Input.set_use_accumulated_input(false)

# move_and_collide_precision.gd
# Using move_and_collide for custom bounce and friction logic
extends CharacterBody2D

# EXPERT NOTE: move_and_slide is for PLATFORMERS. 
# Use move_and_collide for BILLIARDS, PINBALL, or high-speed projectiles 
# where you need the exact KinematicCollision2D object.

@export var bounce_factor: float = 0.8

func _physics_process(delta: float) -> void:
	var collision = move_and_collide(velocity * delta)
	if collision:
		# Bounce velocity off the normal
		velocity = velocity.bounce(collision.get_normal()) * bounce_factor
		
		# Slide slightly along the surface for 'greasy' feel
		velocity += collision.get_remainder().slide(collision.get_normal())

# performance_batch_mover.gd
# Moving 100+ StaticBody2Ds without performance tanking
extends Node2D

# PROBLEM: Moving many StaticBody2Ds per frame is expensive.
# SOLUTION: Disable collision while moving or use AnimatableBody2D 
# which is optimized for code-driven movement.

@onready var platforms: Array = get_children().filter(func(c): return c is AnimatableBody2D)

func _physics_process(delta: float) -> void:
	for p in platforms:
		# AnimatableBody2D correctly calculates velocity for riders
		p.position.x += 100 * delta * sin(Time.get_ticks_msec() / 1000.0)

# Character Rotation via DirectSpaceState2D
extends Node2D

## Using an Area2D for simple ground detection? Overkill.
## Use a PhysicsDirectSpaceState2D query for a more lightweight, code-driven approach.

func is_grounded() -> bool:
    var space_state = get_world_2d().direct_space_state
    
    # Cast a small segment below the player
    var query = PhysicsRayQueryParameters2D.create(global_position, global_position + Vector2.DOWN * 5.0)
    query.exclude = [get_parent().get_rid()] # Exclude self
    
    var result = space_state.intersect_ray(query)
    return !result.is_empty()

# physics_direct_space_query.gd
# Low-level space state queries for complex AI vision [Raycasting]
extends Node2D

# EXPERT NOTE: Querying the space state directly is the fastest way 
# to perform raycasts in bulk without creating nodes.

func check_line_of_sight(from: Vector2, to: Vector2) -> bool:
	var space_state = get_world_2d().direct_space_state
	
	# Configure the query
	var query = PhysicsRayQueryParameters2D.create(from, to)
	query.collision_mask = 1 # World layer
	query.exclude = [get_parent().get_rid()] # Exclude self
	
	var result = space_state.intersect_ray(query)
	
	# result is empty if nothing was hit
	return result.is_empty()

# physics_interpolation_smoothing.gd
# Manual jitter reduction for PhysicsBody2D [12, 13]
extends CharacterBody2D

# PROBLEM: Physics runs at 60Hz, Monitors run at 144Hz+. This causes 
# 'micro-stutter' as the rendering frame is between physics frames.
# SOLUTION: In Godot 4.3+, use 'Physics Interpolation'. For older versions, 
# or custom needs, use this 'smoothing node' pattern.

@onready var visual_node: Node2D = $Sprite2D

func _process(_delta: float) -> void:
	# Calculate how much time has passed since the last physics frame
	var weight = Engine.get_physics_interpolation_fraction()
	
	# Interpolate the sprite's position between previous and current physics state
	# visual_node.global_position = _prev_pos.lerp(global_position, weight)
	pass # Logic is cleaner if using built-in Godot 4 interpolation settings

# skills/2d-physics/code/physics_queries.gd
extends Node2D

## High-Performance Physics Queries Pattern
## Demonstrates using PhysicsDirectSpaceState2D for queries outside the main tree.

func perform_expert_raycast(from: Vector2, to: Vector2, exclude: Array[RID] = []) -> Dictionary:
    # 1. Access the direct space state (Thread-safe only in _physics_process)
    var space_state := get_world_2d().direct_space_state
    
    # 2. Configure the query
    var query := PhysicsRayQueryParameters2D.create(from, to)
    query.exclude = exclude
    query.collision_mask = 0b0001 # Layer 1 (World)
    
    # Optional: Enable hit_from_inside if needed
    # query.hit_from_inside = true
    
    # 3. Execute
    var result := space_state.intersect_ray(query)
    
    if result:
        # print("Hit: ", result.collider)
        return result
    return {}

func perform_shapecast(origin: Vector2, shape: Shape2D, motion: Vector2) -> Array[Dictionary]:
    # ShapeCast2D is great as a node, but for manual queries:
    var space_state := get_world_2d().direct_space_state
    
    var query := PhysicsShapeQueryParameters2D.new()
    query.shape = shape
    query.transform = Transform2D(0, origin)
    query.motion = motion
    
    # intersect_shape is for overlap detection
    # cast_motion is for finding how far a shape can move before hitting something
    var results := space_state.intersect_shape(query)
    return results

## WHY USE THIS?
## Bypassing the Node2D tree for physics queries is significantly faster 
## when performing hundreds of checks (e.g., AI vision, projectile prediction).

# skills/2d-physics/scripts/physics_query_cache.gd
extends Node2D

## Physics Query Cache (Expert Pattern)
## Caches expensive Area/Shape queries to avoid running them every frame.
## Useful for "Radar" scans or dense AI environments.

class_name PhysicsQueryCache

@export var scan_radius: float = 300.0
@export var scan_interval: float = 0.2
@export_flags_2d_physics var collision_mask: int = 1

var _cached_results: Array[Dictionary] = []
var _timer: float = 0.0

signal results_updated(results: Array[Dictionary])

func _physics_process(delta: float) -> void:
    _timer -= delta
    if _timer <= 0.0:
        _timer = scan_interval
        _perform_scan()

func _perform_scan() -> void:
    var space = get_world_2d().direct_space_state
    var query = PhysicsShapeQueryParameters2D.new()
    var shape = CircleShape2D.new()
    shape.radius = scan_radius
    
    query.shape = shape
    query.transform = global_transform
    query.collision_mask = collision_mask
    
    _cached_results = space.intersect_shape(query)
    results_updated.emit(_cached_results)

func get_results() -> Array[Dictionary]:
    return _cached_results

func get_closest() -> Node2D:
    var closest: Node2D = null
    var min_dist = INF
    
    for res in _cached_results:
        var collider = res.collider as Node2D
        if collider and collider != self:
             var d = global_position.distance_squared_to(collider.global_position)
             if d < min_dist:
                 min_dist = d
                 closest = collider
    return closest

## EXPERT USAGE:
## Attach to player/AI. Connect to 'results_updated' or poll 'get_results()'.
## Vastly cheaper than calling intersect_shape every frame.

# physics_server_direct_body.gd
# High-performance physics using PhysicsServer2D directly [17]
extends Node2D

# EXPERT NOTE: For 1000s of objects (bullets, debris), PhysicsServer2D 
# is significantly faster than using RigidBody2D nodes as it 
# bypasses the scene tree overhead.

var bodies: Array[RID] = []
var shape: RID

func _ready() -> void:
	shape = PhysicsServer2D.circle_shape_create()
	PhysicsServer2D.shape_set_data(shape, 10.0) # Radius 10
	
	for i in range(100):
		var body = PhysicsServer2D.body_create()
		PhysicsServer2D.body_set_mode(body, PhysicsServer2D.BODY_MODE_RIGID)
		PhysicsServer2D.body_add_shape(body, shape)
		PhysicsServer2D.body_set_space(body, get_world_2d().space)
		PhysicsServer2D.body_set_state(body, PhysicsServer2D.BODY_STATE_TRANSFORM, Transform2D(0, Vector2(randf()*500, randf()*500)))
		bodies.append(body)

func _exit_tree() -> void:
	# ALWAYS clean up RIDs manually to prevent memory leaks
	for body in bodies:
		PhysicsServer2D.free_rid(body)
	PhysicsServer2D.free_rid(shape)

# PhysicsServer2D High-Performance Swarm
extends Node2D

## For thousands of objects, bypassing the SceneTree is mandatory.
## This script manages raw physics bodies via the PhysicsServer2D.

var bodies = []
var shape

func _ready() -> void:
    shape = PhysicsServer2D.circle_shape_create()
    PhysicsServer2D.shape_set_data(shape, 10.0) # Radius 10

    for i in range(1000):
        var body = PhysicsServer2D.body_create()
        PhysicsServer2D.body_set_space(body, get_world_2d().space)
        PhysicsServer2D.body_add_shape(body, shape)
        
        # Set initial position
        var transform = Transform2D(0, Vector2(randf() * 1000, randf() * 1000))
        PhysicsServer2D.body_set_state(body, PhysicsServer2D.BODY_STATE_TRANSFORM, transform)
        
        bodies.append(body)

func _exit_tree() -> void:
    # Manual memory management is required for Server objects
    for body in bodies:
        PhysicsServer2D.free_rid(body)
    PhysicsServer2D.free_rid(shape)

# raycast_hit_prediction.gd
# Using RayCast2D for hitscan weapons and prediction logic
extends RayCast2D

# EXPERT NOTE: Don't rely solely on '_physics_process' update. 
# Force updates for immediate logic resolution (like rapid fire).

func fire_shot() -> void:
	# Move ray to weapon muzzle
	force_raycast_update()
	
	if is_colliding():
		var target = get_collider()
		var point = get_collision_point()
		var normal = get_collision_normal()
		
		_apply_impact_vfx(point, normal)
		if target.has_method("take_damage"):
			target.take_damage(25)

func _apply_impact_vfx(_point: Vector2, _normal: Vector2):
	pass

# Optimized RayCast2D AI Detection Stack
extends Node2D

## Expert pattern: Using a shared RayCast2D to perform multiple 
## directional checks in one frame to optimize NPC vision swarms.

@onready var vision_ray: RayCast2D = $VisionRay

func scan_for_target(target: Node2D, angles: Array[float], max_range: float) -> bool:
	vision_ray.enabled = true
	vision_ray.target_position = Vector2.RIGHT * max_range
	
	for angle in angles:
		vision_ray.rotation = angle
		# MANDATORY: force_raycast_update() must be called after rotation
		# if checking multiple directions in the same physics frame.
		vision_ray.force_raycast_update()
		
		if vision_ray.is_colliding() and vision_ray.get_collider() == target:
			vision_ray.enabled = false
			return true
			
	vision_ray.enabled = false
	return false

# Safe RigidBody2D State Modification
extends RigidBody2D

## NEVER modify position or linear_velocity in _process or _physics_process.
## Use _integrate_forces for thread-safe access to the PhysicsDirectBodyState.

func _integrate_forces(state: PhysicsDirectBodyState2D) -> void:
    # Example: Teleporting safely mid-collision
    if Input.is_action_just_pressed("teleport"):
        var new_transform = Transform2D(state.transform.get_rotation(), Vector2.ZERO)
        state.transform = new_transform
    
    # Example: Applying a custom impulse that overrides existing velocity
    if Input.is_action_just_pressed("jump"):
        state.linear_velocity.y = -500

# shapecast_aoe_detection.gd
# Using ShapeCast2D for robust area-of-effect detection [Ray vs Shape]
extends ShapeCast2D

# EXPERT NOTE: RayCasts are pins. ShapeCasts are volumes. 
# Use ShapeCast2D for ground detection or melee swings to 
# prevent "skinny" collisions from missing targets.

func check_grounded() -> bool:
	# A CircleShape2D cast downwards is more stable for slopes
	# than a single RayCast2D.
	force_shapecast_update()
	return is_colliding()

func get_all_targets() -> Array:
	var hits = []
	for i in range(get_collision_count()):
		hits.append(get_collider(i))
	return hits

# ShapeCast2D AOE Detection Patterns
extends ShapeCast2D

## Using ShapeCast2D for robust AOE detection. 
## Unlike Area2D, ShapeCast2D detects collisions at the EXACT moment of query.

func get_impact_entities(faction_mask: int) -> Array[Node2D]:
	collision_mask = faction_mask
	force_shapecast_update()
	
	var entities: Array[Node2D] = []
	for i in range(get_collision_count()):
		var col = get_collider(i)
		if col is Node2D:
			entities.append(col)
			
	return entities

# Fixed Timestep Sub-stepping Logic
extends CharacterBody2D

## For extremely fast-moving objects (bullets), standard collision fails.
## Sub-stepping manually breaks the frame into smaller physics steps.

@export var velocity_per_second: Vector2 = Vector2(5000, 0)
@export var sub_steps: int = 4

func _physics_process(delta: float) -> void:
    var step_delta = delta / sub_steps
    for i in range(sub_steps):
        var collision = move_and_collide(velocity_per_second * step_delta)
        if collision:
            _handle_collision(collision)
            break

func _handle_collision(collision: KinematicCollision2D) -> void:
    print("Impact at: ", collision.get_position())
    queue_free()