# Collider And Rigidbody2D Rules

This manual explains 2D physics rules for this project.

## Core Unity Rule

For 2D physics interactions, objects usually need:

```text
Collider2D
Rigidbody2D
```

At least one of the interacting objects usually needs a Rigidbody2D for collision/trigger events to fire reliably.

## Collider2D

Collider2D defines shape.

Common types:

```text
BoxCollider2D
CircleCollider2D
CapsuleCollider2D
PolygonCollider2D
```

Use:

```text
CapsuleCollider2D -> character/enemy body
BoxCollider2D     -> platforms, attack hitboxes
CircleCollider2D  -> area interaction, simple projectile shape
```

## Rigidbody2D

Rigidbody2D defines physics behavior.

Common body types:

```text
Dynamic
Kinematic
Static
```

Use:

```text
Dynamic   -> Rika, enemies
Kinematic -> dead/stopped enemies or controlled moving platforms
Static    -> usually ground if no Rigidbody2D is needed
```

## Solid vs Trigger

Collider has an `Is Trigger` checkbox.

Solid collider:

```text
Is Trigger: false
Blocks movement
Uses OnCollisionEnter2D / OnCollisionStay2D
```

Trigger collider:

```text
Is Trigger: true
Detects overlap
Does not block movement
Uses OnTriggerEnter2D / OnTriggerStay2D
```

## Current Project Examples

Rika body:

```text
CapsuleCollider2D
Is Trigger: false
Rigidbody2D Dynamic
```

Enemy body:

```text
CapsuleCollider2D
Is Trigger: false
Rigidbody2D Dynamic
Freeze Rotation Z
```

Enemy attack hitbox:

```text
BoxCollider2D
Is Trigger: true
Enabled only during attack frames
```

Fire camp interaction:

```text
CircleCollider2D
Is Trigger: true
RestCheckpoint detects Rika nearby
```

Bullet:

```text
Collider2D trigger
Rigidbody2D gravity scale 0
Script sets velocity
```

## Freeze Rotation

Characters and enemies should usually freeze rotation.

Why:

```text
They should not spin or roll after hitting slopes/enemies.
```

Current enemy script also forces:

```csharp
body.freezeRotation = true;
```

## Gravity Rules

Rika:

```text
Gravity enabled normally
Gravity disabled during dash
Gravity restored after dash
```

Projectiles:

```text
Gravity Scale: 0
```

Enemies:

```text
Gravity enabled so they stay on platforms
```

## Velocity Rules

Use Rigidbody2D velocity for physics movement.

In current Unity version this project uses:

```csharp
body.linearVelocity
```

Use this for:

```text
Rika horizontal movement
Rika jump
Rika dash
Enemy patrol/chase movement
Projectile movement
```

Avoid moving physics characters with:

```csharp
transform.position += ...
transform.Translate(...)
```

unless there is a clear reason. Transform movement can bypass physics.

## Collision Event Matching

Use this rule:

```text
Solid collider -> OnCollisionEnter2D
Trigger collider -> OnTriggerEnter2D
```

Examples:

```text
Rika touching ground -> OnCollisionEnter2D
Bullet hitting enemy -> OnTriggerEnter2D
Rika entering fire camp range -> OnTriggerEnter2D
Enemy attack hitbox touching Rika -> OnTriggerEnter2D
```

## Layers vs Sorting Layers

Do not confuse them.

Physics Layer:

```text
Used for collisions and raycasts.
Configured on GameObject Layer.
```

Sorting Layer:

```text
Used for visual draw order.
Configured on SpriteRenderer.
```

Changing Sorting Layer does not change collision behavior.

## Ledge Check Rules

Enemies use raycasts to avoid falling off platforms.

Owned by:

```text
MonsterContactAttack
```

Important values:

```text
Ground Layers
Ledge Check Horizontal Offset
Ledge Check Vertical Offset
Ledge Check Distance
```

If enemies stop too early or fall off:

```text
Check ground layer mask
Check raycast distance
Check enemy collider size
Check platform collider shape
```

## Enemy Collision Rules

Current behavior:

```text
Enemies ignore other enemy body colliders.
Rika ignores enemy body colliders during dash.
Rika still collides with ground during dash.
```

Why:

```text
Enemies should not get stuck pushing each other.
Dash should pass through enemies without being physically blocked.
```

## Debug Checklist

If object falls through ground:

```text
Ground has Collider2D?
Player/enemy has Rigidbody2D?
Player/enemy has Collider2D?
Collider is not trigger?
Layer collision matrix allows contact?
Object is not moving by Transform through the floor?
```

If trigger does not fire:

```text
Is Trigger checked?
At least one object has Rigidbody2D?
Script method name is correct?
Collider is enabled?
GameObject is active?
```

If object rotates:

```text
Freeze Rotation Z
Check Rigidbody2D constraints
Check physics material/friction
```

If knockback feels wrong:

```text
Check hit source transform
Check Rigidbody2D mass
Check knockback force values
Check movement lock duration
```

## Summary

Physics pattern:

```text
Bodies use solid colliders.
Attack areas use trigger colliders.
Projectiles use trigger colliders and velocity.
Characters move through Rigidbody2D.
Sorting layers are visual only.
Physics layers are collision/raycast related.
```