Godot Genre Platformer

# skills/genre-platformer/scripts/advanced_platformer_controller.gd
extends CharacterBody2D

## Advanced Platformer Controller
## Expert implementation of "game feel" mechanics: Coyote Time, Jump Buffering, Apex Modifiers.

class_name AdvancedPlatformerController

@export_group("Movement")
@export var move_speed: float = 200.0
@export var acceleration: float = 1800.0
@export var friction: float = 2000.0
@export var air_acceleration: float = 1200.0
@export var air_friction: float = 800.0

@export_group("Jump")
@export var jump_height: float = 80.0
@export var jump_time_to_peak: float = 0.35
@export var jump_time_to_descent: float = 0.3
@export var variable_jump_height: bool = true

@export_group("Assists")
@export var coyote_time: float = 0.1
@export var jump_buffer: float = 0.15
@export var apex_duration: float = 0.1
@export var apex_gravity_mult: float = 0.5

# Detailed Physics Calculation
@onready var jump_velocity: float = ((2.0 * jump_height) / jump_time_to_peak) * -1.0
@onready var jump_gravity: float = ((-2.0 * jump_height) / (jump_time_to_peak * jump_time_to_peak)) * -1.0
@onready var fall_gravity: float = ((-2.0 * jump_height) / (jump_time_to_descent * jump_time_to_descent)) * -1.0

# State
var _coyote_timer: float = 0.0
var _jump_buffer_timer: float = 0.0
var _is_jumping: bool = false

func _physics_process(delta: float) -> void:
    # 1. Input Handling
    var input_x = Input.get_axis("move_left", "move_right")
    
    # 2. Gravity Application
    var gravity_mult = 1.0
    
    # Apex modifier: reduce gravity at the very peak of jump for "hang time"
    if _is_jumping and abs(velocity.y) < 100.0:
        gravity_mult = apex_gravity_mult
        
    if velocity.y < 0:
        velocity.y += jump_gravity * gravity_mult * delta
    else:
        velocity.y += fall_gravity * gravity_mult * delta
        
    # 3. Timers
    if is_on_floor():
        _coyote_timer = coyote_time
        _is_jumping = false
    else:
        _coyote_timer -= delta
        
    if Input.is_action_just_pressed("jump"):
        _jump_buffer_timer = jump_buffer
    else:
        _jump_buffer_timer -= delta
        
    # 4. Jump Execution
    if _jump_buffer_timer > 0 and (_coyote_timer > 0 or is_on_floor()):
        velocity.y = jump_velocity
        _is_jumping = true
        _jump_buffer_timer = 0
        _coyote_timer = 0
        
    # Variable Jump Height (releasing button cuts jump short)
    if variable_jump_height and Input.is_action_just_released("jump") and velocity.y < 0:
        velocity.y *= 0.5
        
    # 5. Horizontal Movement
    var target_accel = acceleration if is_on_floor() else air_acceleration
    var target_friction = friction if is_on_floor() else air_friction
    
    if input_x != 0:
        velocity.x = move_toward(velocity.x, input_x * move_speed, target_accel * delta)
    else:
        velocity.x = move_toward(velocity.x, 0, target_friction * delta)
        
    move_and_slide()

## EXPERT USAGE:
## Adjust 'Jump Height' and 'Time To Peak' in inspector to tune feel.
## Gravity is calculated automatically from these values.

# coyote_timer.gd
extends Node
class_name CoyoteTimer

# Coyote Time Logic
# Tracks the precise time since the player left the floor to grant a brief jump window.

var time_left: float = 0.0
const MAX_COYOTE: float = 0.15

func update_coyote(is_on_floor: bool, delta: float) -> void:
    if is_on_floor:
        time_left = MAX_COYOTE
    else:
        time_left -= delta

func can_jump() -> bool:
    # Pattern: Avoid exact floating point equality (== 0.0).
    return time_left > 0.0

# custom_collision_slider.gd
extends CharacterBody2D
class_name CustomCollisionSlider

# Custom Collision Slide Response
# Manual calculation of sliding response for high-speed or non-standard physics.

func _physics_process(delta: float) -> void:
    # Use move_and_collide for manual control.
    var collision := move_and_collide(velocity * delta)
    if collision:
        # Expert Pattern: Manually slide along the normal to prevent sticking.
        velocity = velocity.slide(collision.get_normal())

# fast_projectile_ccd.gd
extends RigidBody2D
class_name FastProjectileCCD

# Continuous Collision Detection (CCD) for High-Speed Sprites
# Prevents "tunneling" through thin geometry.

func _ready() -> void:
    # Pattern: Use ray-casting CD for extremely fast, small bullets/sprites.
    continuous_cd = RigidBody2D.CCD_MODE_CAST_RAY
    max_contacts_reported = 1
    contact_monitor = true

# jump_buffer.gd
extends Node
class_name JumpBuffer

# Frame-Perfect Jump Buffering via Unhandled Input
# Captures input outside the physics tick to ensure fast inputs aren't dropped.

var buffer_time_left: float = 0.0
const MAX_BUFFER: float = 0.1

func _unhandled_input(event: InputEvent) -> void:
    # Pattern: Use StringName (&"jump") for optimized input checks.
    if event.is_action_pressed(&"jump"):
        buffer_time_left = MAX_BUFFER

func _physics_process(delta: float) -> void:
    if buffer_time_left > 0.0:
        buffer_time_left -= delta

func consume_jump() -> bool:
    if buffer_time_left > 0.0:
        buffer_time_left = 0.0
        return true
    return false

# ledge_grab_sensor.gd
extends Node2D
class_name LedgeGrabSensor

# Ledge Grabbing using ShapeCast2D logic
# Performs a nodeless shape query to detect precise ledge geometry.

@export var body: CharacterBody2D

func check_ledge() -> bool:
    var space_state := get_world_2d().direct_space_state
    
    # Create an on-demand circle shape for detection.
    var shape := CircleShape2D.new()
    shape.radius = 4.0
    
    var query := PhysicsShapeQueryParameters2D.new()
    query.shape = shape
    query.transform = global_transform
    query.exclude = [body.get_rid()]
    
    var hits := space_state.intersect_shape(query)
    return not hits.is_empty()

extends CharacterBody2D
class_name OneWayDropHandler

## Expert One-Way Drop Logic (Godot 4.6).
## Down + Jump intentionally drops through platforms.

const PLATFORM_LAYER = 4 # Example layer for one-way platforms

func _physics_process(_delta: float) -> void:
	if Input.is_action_pressed("down") and Input.is_action_just_pressed("jump"):
		_drop_through()

func _drop_through() -> void:
	# Temporarily disable the collision mask for the platform layer
	set_collision_mask_value(PLATFORM_LAYER, false)
	
	# Restore after a short delay
	await get_tree().create_timer(0.2).timeout
	set_collision_mask_value(PLATFORM_LAYER, true)

## [SKILL NOTICE]: Use 'set_collision_mask_value()' to temporarily ignore 
## one-way platform layers. Use 'await' for precise, non-blocking timing.

# platformer_animation_sync.gd
extends Node
class_name PlatformerAnimationSync

# State-Driven AnimationTree Sync
# Safely updates logic conditions for AnimationTree without negation operators.

@export var anim_tree: AnimationTree
@export var character: CharacterBody2D

func _physics_process(_delta: float) -> void:
    if not anim_tree or not character: return
    
    var is_moving := abs(character.velocity.x) > 10.0
    var is_in_air := not character.is_on_floor()
    
    # Pattern: Explicitly set booleans for logic-safe Advance Conditions.
    anim_tree.set("parameters/conditions/is_moving", is_moving)
    anim_tree.set("parameters/conditions/is_idle", not is_moving)
    anim_tree.set("parameters/conditions/is_airborne", is_in_air)
    anim_tree.set("parameters/conditions/is_on_ground", not is_in_air)

# skills/genre-platformer/scripts/platformer_camera.gd
extends Camera2D

## Platformer Camera Expert Pattern
## "Look Ahead" camera that smooths movement and anticipates player direction.

class_name PlatformerCamera

@export var target: Node2D
@export var look_ahead_dist: float = 100.0
@export var lerp_speed: float = 3.0
@export var vertical_offset: float = -50.0

var _current_look_ahead_x: float = 0.0

func _physics_process(delta: float) -> void:
    if not target: return
    
    # 1. Base Position
    var target_pos = target.global_position
    target_pos.y += vertical_offset
    
    # 2. Look Ahead Logic
    if target is CharacterBody2D:
        var v_x = target.velocity.x
        if abs(v_x) > 10.0:
            var dir = sign(v_x)
            _current_look_ahead_x = lerp(_current_look_ahead_x, dir * look_ahead_dist, lerp_speed * delta)
        else:
             # Center when stopped
             _current_look_ahead_x = lerp(_current_look_ahead_x, 0.0, lerp_speed * delta)
    
    target_pos.x += _current_look_ahead_x
    
    # 3. Position Smoothing (or use Camera2D built-in)
    # We apply manually for more control if position_smoothing is off
    global_position = global_position.lerp(target_pos, 5.0 * delta)

## EXPERT USAGE:
## Assign Player to 'target'. Ensure Camera2D is NOT child of player 
## (or use RemoteTransform2D) to avoid jitter.

extends CharacterBody2D
class_name ExpertPlatformerController

## Expert Platformer Physics (Godot 4.6).
## Implements Coyote Time and Jump Buffering for perfect feel.

@export var speed: float = 300.0
@export var jump_velocity: float = -400.0
@export var coyote_time: float = 0.15
@export var jump_buffer: float = 0.15

var gravity: float = ProjectSettings.get_setting("physics/2d/default_gravity")
var _coyote_timer: float = 0.0
var _buffer_timer: float = 0.0

func _physics_process(delta: float) -> void:
	# Add the gravity.
	if not is_on_floor():
		velocity.y += gravity * delta
		_coyote_timer += delta
	else:
		_coyote_timer = 0.0

	# Handle Jump Buffer
	if Input.is_action_just_pressed("jump"):
		_buffer_timer = jump_buffer
	
	_buffer_timer -= delta

	# Handle Jump logic
	if _buffer_timer > 0 and _coyote_timer < coyote_time:
		velocity.y = jump_velocity
		_buffer_timer = 0
		_coyote_timer = coyote_time # Consume coyote time

	# Get the input direction and handle the movement/deceleration.
	var direction := Input.get_axis("left", "right")
	if direction:
		velocity.x = lerpf(velocity.x, direction * speed, 0.2)
	else:
		velocity.x = move_toward(velocity.x, 0, speed)

	move_and_slide()

## [SKILL NOTICE]: Use 'lerpf' for movement smoothing and 'move_and_slide()' 
## for standard CharacterBody2D interaction. Time-based buffering is mandatory.

# player_ground_controller.gd
extends CharacterBody2D
class_name PlayerGroundController

# Advanced Ground Movement with Slope Physics
# Configures a CharacterBody2D for constant slope speed and floor snapping.

@export var speed: float = 300.0
var gravity: float = ProjectSettings.get_setting("physics/2d/default_gravity")

func _ready() -> void:
    # Expert Tip: Enable constant speed on slopes to prevent "launching" off peaks.
    floor_constant_speed = true
    floor_max_angle = deg_to_rad(45.0)
    floor_snap_length = 8.0 # Snap to ground even when running down slopes.

func _physics_process(delta: float) -> void:
    # NEVER multiply velocity by delta before move_and_slide().
    velocity.y += gravity * delta
    
    var input_dir := Input.get_axis(&"ui_left", &"ui_right")
    velocity.x = input_dir * speed
    
    move_and_slide()

# synchronized_platform.gd
extends AnimatableBody2D
class_name SynchronizedPlatform

# Synchronized Moving Platform
# Ensures platforms move flawlessly in sync with the physics tick.

func _ready() -> void:
    # Pattern: Mandatory for platforms moved by AnimationPlayer/Tweens.
    sync_to_physics = true

# variable_jump.gd
extends Node
class_name VariableJump

# Variable Jump Height (Early Release Cutoff)
# Cuts upward momentum if the jump button is released mid-ascent.

@export var body: CharacterBody2D
@export var min_jump_velocity: float = -200.0

func _physics_process(_delta: float) -> void:
    # Pattern: Only cut if moving UP and button just released.
    if Input.is_action_just_released(&"jump") and body.velocity.y < min_jump_velocity:
        body.velocity.y = min_jump_velocity

# wall_slide_sensor.gd
extends Node2D
class_name WallSlideSensor

# Wall Sliding via Nodeless Physics Raycast
# Direct query using PhysicsServer2D for zero-latency detection without nodes.

@export var body: CharacterBody2D

func check_wall(look_direction: float) -> bool:
    var space_state := get_world_2d().direct_space_state
    
    # Cast ray slightly outside the collision shape.
    var ray_end := global_position + Vector2(look_direction * 15.0, 0)
    var query := PhysicsRayQueryParameters2D.create(global_position, ray_end)
    query.exclude = [body.get_rid()]
    
    var result := space_state.intersect_ray(query)
    return not result.is_empty()