UnityPlatformer.PlatformerCollider2D.Move C# (CSharp) Method

    public Vector3 Move(Vector3 velocity, float delta) {
      Log.Silly("(PlatformerCollider2D) Move({0}, {1}, {2})", gameObject.name, velocity.ToString("F4"), delta);
      // swap layers, this makes possible to collide with something inside
      // my own layer like boxes
      previousLayer = gameObject.layer;
      gameObject.layer = 2; // Ignore Raycast

      UpdateRaycastOrigins();

      // debug
      var b = bounds;
      b.Draw(transform, new Color(1,1,1, 0.25f));
      b.center += velocity;
      b.Draw(transform, new Color(0,0,1, 0.5f));
      b.Expand(minDistanceToEnv * 2);
      //b.center -= new Vector3(minDistanceToEnv, minDistanceToEnv, 0);
      b.Draw(transform, new Color(0,0,1, 0.75f));

      // set previous collisions and reset current one
      pCollisions = collisions.Clone();
      collisions.Reset();

      // Climb or descend a slope if in range
      if (enableSlopes) {
        UpdateCurrentSlope(velocity);

        // TODO PERF add: pCcollisions.below, so wont be testing while falling
        // if (collisions.slopeAngle != 0 && pCollisions.below) {
        if (collisions.slopeAngle != 0) {
          //Debug.Log("velocity before" + velocity.ToString("F4"));

          ClimbSlope(ref velocity);
          DescendSlope(ref velocity);

          //Debug.Log("velocity after" + velocity.ToString("F4"));
        }
      }



      // be sure we stay outside others colliders
      if (!disableWorldCollisions) {
        ForeachLeftRay(skinWidth, ref velocity, HorizontalCollisions);
        ForeachRightRay(skinWidth, ref velocity, HorizontalCollisions);

        if (velocity.y > 0) {
          ForeachFeetRay(skinWidth, ref velocity, VerticalCollisions);
          ForeachHeadRay(skinWidth, ref velocity, VerticalCollisions);
        } else {
          ForeachFeetRay(skinWidth, ref velocity, VerticalCollisions);
        }
      }

      if (Math.Abs(velocity.x) < minTranslation) {
        velocity.x = 0;
      }
      if (Math.Abs(velocity.y) < minTranslation) {
        velocity.y = 0;
      }

      if (useRigidbody2D) {
        rigidBody2D.velocity = velocity / delta;
      } else {
        transform.Translate(velocity);
      }
      collisions.velocity = velocity;
      ConsolidateCollisions();

      gameObject.layer = previousLayer;

      b = bounds;
      b.center += velocity;
      b.Draw(transform, new Color(0,1,1,0.25f));

      Log.Silly("(PlatformerCollider2D) Moved({0}, {1}, {2})", gameObject.name, velocity.ToString("F4"), delta);

      return velocity;
    }

        /// <summary>
        /// Managed update called by UpdateManager
        /// Transform Input into platformer magic :)
        /// </summary>
        public virtual void PlatformerUpdate(float delta)
        {
            frozen -= delta;
            int             prio = 0;
            int             tmp;
            CharacterAction action = null;

            if (frozen < 0)
            {
                foreach (var i in actions)
                {
                    tmp = i.WantsToUpdate(delta);
                    if (tmp < 0)
                    {
                        i.PerformAction(Time.fixedDeltaTime);
                    }
                    else if (prio < tmp)
                    {
                        prio   = tmp;
                        action = i;
                    }
                }
            }

            // reset / defaults
            pc2d.disableWorldCollisions = false;
            PostUpdateActions a = PostUpdateActions.WORLD_COLLISIONS | PostUpdateActions.APPLY_GRAVITY;

            if (action != null)
            {
                if (lastAction != action)
                {
                    action.GainControl(delta);
                }

                action.PerformAction(Time.fixedDeltaTime);
                a = action.GetPostUpdateActions();
            }

            if (Utils.biton((int)a, (int)PostUpdateActions.APPLY_GRAVITY))
            {
                // TODO REVIEW x/y gravity...
                velocity.y += pc2d.gravity.y * delta;
            }

            if (!Utils.biton((int)a, (int)PostUpdateActions.WORLD_COLLISIONS))
            {
                pc2d.disableWorldCollisions = true;
            }

            if (Mathf.Abs(velocity.x) < minVelocity)
            {
                velocity.x = 0.0f;
            }

            if (Mathf.Abs(velocity.y) < minVelocity)
            {
                velocity.y = 0.0f;
            }

            if (onBeforeMove != null)
            {
                onBeforeMove(this, delta);
            }

            pc2d.Move((velocity + worldVelocity) * delta, delta);

            if (onAfterMove != null)
            {
                onAfterMove(this, delta);
            }


            // this is meant to fix jump and falling hit something unexpected
            if (pc2d.collisions.above || pc2d.collisions.below)
            {
                velocity.y = 0;
            }

            if (pc2d.collisions.below)
            {
                fallingCD.Reset();
                groundCD.Reset();
                SolfEnterState(States.OnGround);
            }
            else
            {
                groundCD.Increment();
                // give some margin
                if (groundCD.Ready())
                {
                    SolfExitState(States.OnGround);
                }

                // falling but not wallsliding
                if (velocity.y < 0 &&
                    !IsOnState(States.WallSliding) &&
                    !IsOnState(States.Liquid) &&
                    !IsOnState(States.Rope))
                {
                    fallingCD.Increment();
                    if (fallingCD.Ready())
                    {
                        SolfEnterState(States.Falling);
                    }
                }
            }

            if (lastAction != null && lastAction != action)
            {
                lastAction.LoseControl(delta);
            }

            lastAction = action;
        }