pastemyst

(untitled)

(at edit #0)

present

movement

Unocopy raw

public class Movement : MonoBehaviour
{
    public float moveSpeed = 5f;
    public float jumpForce = 10f;
    public float airControl = 0.5f; // How much control in air (0-1)

public float rotationSpeed = 5f; // How fast to rotate back to upright
    public LayerMask groundLayer; // Set this to your ground/circle layers
    public float groundCheckDistance = 0.2f;

private GrapplingHook grapple;
    private Rigidbody2D rb;
    private Vector2 groundNormal = Vector2.up;
    private bool isGrounded;
    void Awake()
    {
        rb = GetComponent<Rigidbody2D>();
        grapple = GetComponent<GrapplingHook>();
    }

void Update()
    {
        CheckGroundNormal();
        HandleRotation();

float moveInput = Input.GetAxis("Horizontal");
        if (!grapple.isGrappling)
        {
            // Only override velocity when there's input
            // This preserves swing momentum when you let go
            if (Mathf.Abs(moveInput) > 0.01f)
            {
                // Use air control multiplier for smoother transitions
                float control = IsGrounded() ? 1f : airControl;
                rb.linearVelocity = new Vector2(
                    moveInput * moveSpeed * control,
                    rb.linearVelocity.y
                );
            }
        }
        if (Input.GetButtonDown("Jump") && IsGrounded())
        {
            RaycastHit2D hit = Physics2D.Raycast(rb.position, -transform.up, groundCheckDistance, groundLayer);

if (hit.collider != null)
            {
                // Jump perpendicular to surface
                rb.linearVelocity = hit.normal * jumpForce;
            }
            else
            {
                // Fallback to normal jump
                rb.linearVelocity = new Vector2(rb.linearVelocity.x, jumpForce);
            }
        }
    }

void CheckGroundNormal()
    {
        // Find nearby ground using OverlapCircle
        Collider2D nearbyGround = Physics2D.OverlapCircle(rb.position, groundCheckDistance, groundLayer);

if (nearbyGround != null)
        {
            // Get the closest point on the surface to the player
            Vector2 closestPoint = nearbyGround.ClosestPoint(rb.position);

// The normal points FROM the surface TO the player
            groundNormal = ((Vector2)rb.position - closestPoint).normalized;
            isGrounded = true;
        }
        else
        {
            groundNormal = Vector2.up;
            isGrounded = false;
        }
    }

void HandleRotation()
    {
        if (IsGrounded())
        {
            // Rotate to align with the surface
            float targetAngle = Mathf.Atan2(groundNormal.x, groundNormal.y) * Mathf.Rad2Deg;
            float currentAngle = transform.eulerAngles.z;
            float newAngle = Mathf.LerpAngle(currentAngle, targetAngle, rotationSpeed * Time.deltaTime);
            transform.rotation = Quaternion.Euler(0, 0, newAngle);
        }
        else
        {
            // When in air, smoothly rotate back to upright (0 degrees)
            float currentAngle = transform.eulerAngles.z;
            float newAngle = Mathf.LerpAngle(currentAngle, 0, rotationSpeed * Time.deltaTime);
            transform.rotation = Quaternion.Euler(0, 0, newAngle);
        }
    }

bool IsGrounded()
    {
        float extraHeight = 0.1f;
        RaycastHit2D hit = Physics2D.Raycast(rb.position, Vector2.down, extraHeight);
        return hit.collider != null;
    }

}

planet grav

Beefcopy raw

public class Attractor : MonoBehaviour
{
    public LayerMask AttractionLayer;
    public float gravity = 10;
    [SerializeField] private float Radius = 10;
    public List<Collider2D> AttractedObjects = new List<Collider2D>();
    [HideInInspector] public Transform attractorTransform;

// Start is called once before the first execution of Update after the MonoBehaviour is created
    void Awake()
    {
        attractorTransform = GetComponent<Transform>();
    }

// Update is called once per frame
    void Update()
    {
        SetAttractedObjects();
    }
    private void FixedUpdate()
    {
        AttractObjects();
    }

void SetAttractedObjects()
    {
        AttractedObjects = Physics2D.OverlapCircleAll(attractorTransform.position, Radius, AttractionLayer).ToList();
    }

void AttractObjects()
    {
        for(int  i = 0; i < AttractedObjects.Count; i++)
        {
            AttractedObjects[i].GetComponent<Attractable>().Attract(this);
        }
    }

private void OnDrawGizmosSelected()
    {
        Gizmos.color = Color.magenta;
        Gizmos.DrawWireSphere(transform.position, Radius);
    }
}

attractable

Unocopy raw

public class Attractable : MonoBehaviour
{
    [SerializeField] private bool rotateToCenter = true;
    [HideInInspector] public Attractor currentAttractor;
    [SerializeField] private float gravityStrength = 100;

Transform m_transform;
    Collider2D m_collider;
    Rigidbody2D m_rigidbody;
    // Start is called once before the first execution of Update after the MonoBehaviour is created
    private void Start()
    {
        m_transform = GetComponent<Transform>();
        m_collider = GetComponent<Collider2D>();
        m_rigidbody = GetComponent<Rigidbody2D>();
    }

// Update is called once per frame
    private void Update()
    {
        if (currentAttractor != null) 
        {
            if (!currentAttractor.AttractedObjects.Contains(m_collider))
            {
                currentAttractor = null;
                return;
            }
            if (rotateToCenter) RotateToCenter();
            m_rigidbody.gravityScale = 0;
        }
        else
        {
            m_rigidbody.gravityScale = 1;
        }
    }
    public void Attract(Attractor attractorObj)
    {
        Vector2 attractDir = ((Vector2)attractorObj.attractorTransform.position - m_rigidbody.position).normalized;
        m_rigidbody.AddForce(attractDir*-attractorObj.gravity *gravityStrength * Time.fixedDeltaTime);

if(currentAttractor == null)
        {
            currentAttractor = attractorObj;
        }
    }

void RotateToCenter()
    {
        if (currentAttractor != null)
        {
            Vector2 distanceVector = (Vector2)currentAttractor.attractorTransform.position - (Vector2)(m_transform.position);
            float angle = Mathf.Atan2(distanceVector.y, distanceVector.x) * Mathf.Rad2Deg;
            m_transform.rotation = Quaternion.AngleAxis(angle + 90, Vector3.forward);
        }
    }
}

(untitled)

F*copy raw

created at:

stats: 206 lines, 594 words, 6.48kb